timeout.c File Reference

#include "postgres.h"
#include <sys/time.h>
#include "miscadmin.h"
#include "storage/proc.h"
#include "utils/timeout.h"
#include "utils/timestamp.h"

Include dependency graph for timeout.c:

Go to the source code of this file.

Data Structures
struct	timeout_params

Macros
#define	disable_alarm()   (alarm_enabled = false)
#define	enable_alarm()   (alarm_enabled = true)

Typedefs
typedef struct timeout_params	timeout_params

Functions
static int	find_active_timeout (TimeoutId id)
static void	insert_timeout (TimeoutId id, int index)
static void	remove_timeout_index (int index)
static void	enable_timeout (TimeoutId id, TimestampTz now, TimestampTz fin_time)
static void	schedule_alarm (TimestampTz now)
static void	handle_sig_alarm (SIGNAL_ARGS)
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_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)

Variables
static timeout_params	all_timeouts [MAX_TIMEOUTS]
static bool	all_timeouts_initialized = false
static volatile int	num_active_timeouts = 0
static timeout_params *volatile	active_timeouts [MAX_TIMEOUTS]
static volatile sig_atomic_t	alarm_enabled = false
static volatile sig_atomic_t	signal_pending = false
static TimestampTz	signal_due_at = 0

Macro Definition Documentation

disable_alarm

#define disable_alarm

(

)

(alarm_enabled = false)

Definition at line 68 of file timeout.c.

Referenced by disable_all_timeouts(), disable_timeout(), disable_timeouts(), enable_timeout_after(), enable_timeout_at(), enable_timeouts(), handle_sig_alarm(), InitializeTimeouts(), and reschedule_timeouts().

enable_alarm

#define enable_alarm

(

)

(alarm_enabled = true)

Definition at line 69 of file timeout.c.

Referenced by schedule_alarm().

Typedef Documentation

timeout_params

typedef struct timeout_params timeout_params

Function Documentation

disable_all_timeouts()

void disable_all_timeouts

(

bool

keep_indicators

)

Definition at line 687 of file timeout.c.

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

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

{
    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;
    }
}

disable_timeout()

void disable_timeout	(	TimeoutId	id,
		bool	keep_indicator
	)

Definition at line 621 of file timeout.c.

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

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

{
    /* 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());
}

disable_timeouts()

void disable_timeouts	(	const DisableTimeoutParams *	timeouts,
		int	count
	)

Definition at line 654 of file timeout.c.

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

Referenced by LockErrorCleanup(), and ProcSleep().

{
    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());
}

enable_timeout()

static void enable_timeout ( TimeoutId  id, TimestampTz  now, TimestampTz  fin_time  )

static

Definition at line 156 of file timeout.c.

References timeout_params::active, all_timeouts_initialized, Assert, timeout_params::fin_time, find_active_timeout(), i, timeout_params::indicator, insert_timeout(), now(), num_active_timeouts, remove_timeout_index(), timeout_params::start_time, and timeout_params::timeout_handler.

Referenced by enable_timeout_after(), enable_timeout_at(), and enable_timeouts().

{
    int         i;

    /* Assert request is sane */
    Assert(all_timeouts_initialized);
    Assert(all_timeouts[id].timeout_handler != NULL);

    /*
     * If this timeout was already active, momentarily disable it.  We
     * interpret the call as a directive to reschedule the timeout.
     */
    if (all_timeouts[id].active)
        remove_timeout_index(find_active_timeout(id));

    /*
     * Find out the index where to insert the new timeout.  We sort by
     * fin_time, and for equal fin_time by priority.
     */
    for (i = 0; i < num_active_timeouts; i++)
    {
        timeout_params *old_timeout = active_timeouts[i];

        if (fin_time < old_timeout->fin_time)
            break;
        if (fin_time == old_timeout->fin_time && id < old_timeout->index)
            break;
    }

    /*
     * Mark the timeout active, and insert it into the active list.
     */
    all_timeouts[id].indicator = false;
    all_timeouts[id].start_time = now;
    all_timeouts[id].fin_time = fin_time;

    insert_timeout(id, i);
}

enable_timeout_after()

void enable_timeout_after	(	TimeoutId	id,
		int	delay_ms
	)

Definition at line 524 of file timeout.c.

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

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

{
    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);

    /* Set the timer interrupt. */
    schedule_alarm(now);
}

enable_timeout_at()

void enable_timeout_at	(	TimeoutId	id,
		TimestampTz	fin_time
	)

Definition at line 549 of file timeout.c.

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

{
    TimestampTz now;

    /* Disable timeout interrupts for safety. */
    disable_alarm();

    /* Queue the timeout at the appropriate time. */
    now = GetCurrentTimestamp();
    enable_timeout(id, now, fin_time);

    /* Set the timer interrupt. */
    schedule_alarm(now);
}

enable_timeouts()

void enable_timeouts	(	const EnableTimeoutParams *	timeouts,
		int	count
	)

Definition at line 572 of file timeout.c.

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

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

{
    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);
                break;

            case TMPARAM_AT:
                enable_timeout(id, now, timeouts[i].fin_time);
                break;

            default:
                elog(ERROR, "unrecognized timeout type %d",
                     (int) timeouts[i].type);
                break;
        }
    }

    /* Set the timer interrupt. */
    schedule_alarm(now);
}

find_active_timeout()

static int find_active_timeout ( TimeoutId  id )

static

Definition at line 94 of file timeout.c.

References i, and num_active_timeouts.

Referenced by disable_timeout(), disable_timeouts(), and enable_timeout().

{
    int         i;

    for (i = 0; i < num_active_timeouts; i++)
    {
        if (active_timeouts[i]->index == id)
            return i;
    }

    return -1;
}

get_timeout_active()

bool get_timeout_active

(

TimeoutId

id

)

Definition at line 716 of file timeout.c.

References timeout_params::active.

Referenced by disable_statement_timeout(), and enable_statement_timeout().

{
    return all_timeouts[id].active;
}

get_timeout_finish_time()

TimestampTz get_timeout_finish_time

(

TimeoutId

id

)

Definition at line 763 of file timeout.c.

References timeout_params::fin_time.

Referenced by ProcessInterrupts().

{
    return all_timeouts[id].fin_time;
}

get_timeout_indicator()

bool get_timeout_indicator	(	TimeoutId	id,
		bool	reset_indicator
	)

Definition at line 729 of file timeout.c.

References timeout_params::indicator.

Referenced by ProcessInterrupts().

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

get_timeout_start_time()

TimestampTz get_timeout_start_time

(

TimeoutId

id

)

Definition at line 749 of file timeout.c.

References timeout_params::start_time.

Referenced by ProcSleep().

{
    return all_timeouts[id].start_time;
}

handle_sig_alarm()

static void handle_sig_alarm ( SIGNAL_ARGS  )

static

Definition at line 348 of file timeout.c.

References alarm_enabled, disable_alarm, timeout_params::fin_time, GetCurrentTimestamp(), HOLD_INTERRUPTS, timeout_params::indicator, MyLatch, now(), num_active_timeouts, remove_timeout_index(), RESUME_INTERRUPTS, schedule_alarm(), SetLatch(), signal_pending, and timeout_params::timeout_handler.

Referenced by InitializeTimeouts().

{
    int         save_errno = errno;

    /*
     * Bump the holdoff counter, to make sure nothing we call will process
     * interrupts directly. No timeout handler should do that, but these
     * failures are hard to debug, so better be sure.
     */
    HOLD_INTERRUPTS();

    /*
     * SIGALRM is always cause for waking anything waiting on the process
     * latch.
     */
    SetLatch(MyLatch);

    /*
     * Always reset signal_pending, even if !alarm_enabled, since indeed no
     * signal is now pending.
     */
    signal_pending = false;

    /*
     * Fire any pending timeouts, but only if we're enabled to do so.
     */
    if (alarm_enabled)
    {
        /*
         * Disable alarms, just in case this platform allows signal handlers
         * to interrupt themselves.  schedule_alarm() will re-enable if
         * appropriate.
         */
        disable_alarm();

        if (num_active_timeouts > 0)
        {
            TimestampTz now = GetCurrentTimestamp();

            /* While the first pending timeout has been reached ... */
            while (num_active_timeouts > 0 &&
                   now >= active_timeouts[0]->fin_time)
            {
                timeout_params *this_timeout = active_timeouts[0];

                /* Remove it from the active list */
                remove_timeout_index(0);

                /* Mark it as fired */
                this_timeout->indicator = true;

                /* And call its handler function */
                this_timeout->timeout_handler();

                /*
                 * The handler might not take negligible time (CheckDeadLock
                 * for instance isn't too cheap), so let's update our idea of
                 * "now" after each one.
                 */
                now = GetCurrentTimestamp();
            }

            /* Done firing timeouts, so reschedule next interrupt if any */
            schedule_alarm(now);
        }
    }

    RESUME_INTERRUPTS();

    errno = save_errno;
}

InitializeTimeouts()

void InitializeTimeouts

(

void

)

Definition at line 435 of file timeout.c.

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

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

{
    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_initialized = true;

    /* Now establish the signal handler */
    pqsignal(SIGALRM, handle_sig_alarm);
}

insert_timeout()

static void insert_timeout ( TimeoutId  id, int  index  )

static

Definition at line 112 of file timeout.c.

References timeout_params::active, Assert, elog, FATAL, i, timeout_params::index, and num_active_timeouts.

Referenced by enable_timeout().

{
    int         i;

    if (index < 0 || index > num_active_timeouts)
        elog(FATAL, "timeout index %d out of range 0..%d", index,
             num_active_timeouts);

    Assert(!all_timeouts[id].active);
    all_timeouts[id].active = true;

    for (i = num_active_timeouts - 1; i >= index; i--)
        active_timeouts[i + 1] = active_timeouts[i];

    active_timeouts[index] = &all_timeouts[id];

    num_active_timeouts++;
}

RegisterTimeout()

TimeoutId RegisterTimeout	(	TimeoutId	id,
		timeout_handler_proc	handler
	)

Definition at line 469 of file timeout.c.

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

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

{
    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;
}

remove_timeout_index()

static void remove_timeout_index ( int  index )

static

Definition at line 135 of file timeout.c.

References timeout_params::active, Assert, elog, FATAL, i, timeout_params::index, and num_active_timeouts.

Referenced by disable_timeout(), disable_timeouts(), enable_timeout(), and handle_sig_alarm().

{
    int         i;

    if (index < 0 || index >= num_active_timeouts)
        elog(FATAL, "timeout index %d out of range 0..%d", index,
             num_active_timeouts - 1);

    Assert(active_timeouts[index]->active);
    active_timeouts[index]->active = false;

    for (i = index + 1; i < num_active_timeouts; i++)
        active_timeouts[i - 1] = active_timeouts[i];

    num_active_timeouts--;
}

reschedule_timeouts()

void reschedule_timeouts

(

void

)

Definition at line 504 of file timeout.c.

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

Referenced by AbortSubTransaction(), and AbortTransaction().

{
    /* 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());
}

schedule_alarm()

static void schedule_alarm ( TimestampTz  now )

static

Definition at line 206 of file timeout.c.

References elog, enable_alarm, FATAL, timeout_params::fin_time, itimerval::it_value, ITIMER_REAL, MemSet, num_active_timeouts, setitimer(), signal_due_at, signal_pending, and TimestampDifference().

Referenced by disable_timeout(), disable_timeouts(), enable_timeout_after(), enable_timeout_at(), enable_timeouts(), handle_sig_alarm(), and reschedule_timeouts().

{
    if (num_active_timeouts > 0)
    {
        struct itimerval timeval;
        TimestampTz nearest_timeout;
        long        secs;
        int         usecs;

        MemSet(&timeval, 0, sizeof(struct itimerval));

        /*
         * Get the time remaining till the nearest pending timeout.  If it is
         * negative, assume that we somehow missed an interrupt, and force
         * signal_pending off.  This gives us a chance to recover if the
         * kernel drops a timeout request for some reason.
         */
        nearest_timeout = active_timeouts[0]->fin_time;
        if (now > nearest_timeout)
        {
            signal_pending = false;
            /* force an interrupt as soon as possible */
            secs = 0;
            usecs = 1;
        }
        else
        {
            TimestampDifference(now, nearest_timeout,
                                &secs, &usecs);

            /*
             * It's possible that the difference is less than a microsecond;
             * ensure we don't cancel, rather than set, the interrupt.
             */
            if (secs == 0 && usecs == 0)
                usecs = 1;
        }

        timeval.it_value.tv_sec = secs;
        timeval.it_value.tv_usec = usecs;

        /*
         * We must enable the signal handler before calling setitimer(); if we
         * did it in the other order, we'd have a race condition wherein the
         * interrupt could occur before we can set alarm_enabled, so that the
         * signal handler would fail to do anything.
         *
         * Because we didn't bother to disable the timer in disable_alarm(),
         * it's possible that a previously-set interrupt will fire between
         * enable_alarm() and setitimer().  This is safe, however.  There are
         * two possible outcomes:
         *
         * 1. The signal handler finds nothing to do (because the nearest
         * timeout event is still in the future).  It will re-set the timer
         * and return.  Then we'll overwrite the timer value with a new one.
         * This will mean that the timer fires a little later than we
         * intended, but only by the amount of time it takes for the signal
         * handler to do nothing useful, which shouldn't be much.
         *
         * 2. The signal handler executes and removes one or more timeout
         * events.  When it returns, either the queue is now empty or the
         * frontmost event is later than the one we looked at above.  So we'll
         * overwrite the timer value with one that is too soon (plus or minus
         * the signal handler's execution time), causing a useless interrupt
         * to occur.  But the handler will then re-set the timer and
         * everything will still work as expected.
         *
         * Since these cases are of very low probability (the window here
         * being quite narrow), it's not worth adding cycles to the mainline
         * code to prevent occasional wasted interrupts.
         */
        enable_alarm();

        /*
         * If there is already an interrupt pending that's at or before the
         * needed time, we need not do anything more.  The signal handler will
         * do the right thing in the first case, and re-schedule the interrupt
         * for later in the second case.  It might seem that the extra
         * interrupt is wasted work, but it's not terribly much work, and this
         * method has very significant advantages in the common use-case where
         * we repeatedly set a timeout that we don't expect to reach and then
         * cancel it.  Instead of invoking setitimer() every time the timeout
         * is set or canceled, we perform one interrupt and a re-scheduling
         * setitimer() call at intervals roughly equal to the timeout delay.
         * For example, with statement_timeout = 1s and a throughput of
         * thousands of queries per second, this method requires an interrupt
         * and setitimer() call roughly once a second, rather than thousands
         * of setitimer() calls per second.
         *
         * Because of the possible passage of time between when we obtained
         * "now" and when we reach setitimer(), the kernel's opinion of when
         * to trigger the interrupt is likely to be a bit later than
         * signal_due_at.  That's fine, for the same reasons described above.
         */
        if (signal_pending && nearest_timeout >= signal_due_at)
            return;

        /*
         * As with calling enable_alarm(), we must set signal_pending *before*
         * calling setitimer(); if we did it after, the signal handler could
         * trigger before we set it, leaving us with a false opinion that a
         * signal is still coming.
         *
         * Other race conditions involved with setting/checking signal_pending
         * are okay, for the reasons described above.  One additional point is
         * that the signal handler could fire after we set signal_due_at, but
         * still before the setitimer() call.  Then the handler could
         * overwrite signal_due_at with a value it computes, which will be the
         * same as or perhaps later than what we just computed.  After we
         * perform setitimer(), the net effect would be that signal_due_at
         * gives a time later than when the interrupt will really happen;
         * which is a safe situation.
         */
        signal_due_at = nearest_timeout;
        signal_pending = true;

        /* Set the alarm timer */
        if (setitimer(ITIMER_REAL, &timeval, NULL) != 0)
        {
            /*
             * Clearing signal_pending here is a bit pro forma, but not
             * entirely so, since something in the FATAL exit path could try
             * to use timeout facilities.
             */
            signal_pending = false;
            elog(FATAL, "could not enable SIGALRM timer: %m");
        }
    }
}

Variable Documentation

active_timeouts

timeout_params* volatile active_timeouts[MAX_TIMEOUTS]

static

Definition at line 52 of file timeout.c.

alarm_enabled

volatile sig_atomic_t alarm_enabled = false

static

Definition at line 66 of file timeout.c.

Referenced by handle_sig_alarm().

all_timeouts

timeout_params all_timeouts[MAX_TIMEOUTS]

static

Definition at line 44 of file timeout.c.

all_timeouts_initialized

bool all_timeouts_initialized = false

static

Definition at line 45 of file timeout.c.

Referenced by disable_timeout(), disable_timeouts(), enable_timeout(), InitializeTimeouts(), RegisterTimeout(), and reschedule_timeouts().

num_active_timeouts

volatile int num_active_timeouts = 0

static

Definition at line 51 of file timeout.c.

Referenced by disable_all_timeouts(), disable_timeout(), disable_timeouts(), enable_timeout(), find_active_timeout(), handle_sig_alarm(), InitializeTimeouts(), insert_timeout(), remove_timeout_index(), reschedule_timeouts(), and schedule_alarm().

signal_due_at

TimestampTz signal_due_at = 0

static

Definition at line 77 of file timeout.c.

Referenced by schedule_alarm().

signal_pending

volatile sig_atomic_t signal_pending = false

static

Definition at line 76 of file timeout.c.

Referenced by handle_sig_alarm(), and schedule_alarm().