559 lines
14 KiB
C
559 lines
14 KiB
C
/* $NetBSD: ntp_timer.c,v 1.4 1998/08/12 14:11:54 christos Exp $ */
|
|
|
|
/*
|
|
* ntp_timer.c - event timer support routines
|
|
*/
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <errno.h>
|
|
#include <sys/types.h>
|
|
#include <sys/time.h>
|
|
#include <signal.h>
|
|
#include <sys/signal.h>
|
|
|
|
#include "ntpd.h"
|
|
#include "ntp_stdlib.h"
|
|
|
|
/*
|
|
* These routines provide support for the event timer. The timer is
|
|
* implemented by an interrupt routine which sets a flag once every
|
|
* 2**EVENT_TIMEOUT seconds (currently 4), and a timer routine which
|
|
* is called when the mainline code gets around to seeing the flag.
|
|
* The timer routine dispatches the clock adjustment code if its time
|
|
* has come, then searches the timer queue for expiries which are
|
|
* dispatched to the transmit procedure. Finally, we call the hourly
|
|
* procedure to do cleanup and print a message.
|
|
*/
|
|
|
|
/*
|
|
* Alarm flag. The mainline code imports this.
|
|
*/
|
|
volatile int alarm_flag;
|
|
|
|
/*
|
|
* adjust and hourly counters
|
|
*/
|
|
static u_long adjust_timer;
|
|
static u_long hourly_timer;
|
|
|
|
/*
|
|
* Imported from the leap module. The leap timer.
|
|
*/
|
|
extern u_long leap_timer;
|
|
|
|
/*
|
|
* Statistics counter for the interested.
|
|
*/
|
|
volatile u_long alarm_overflow;
|
|
|
|
#define HOUR (60*60)
|
|
|
|
/*
|
|
* Current_time holds the number of seconds since we started, in
|
|
* increments of 2**EVENT_TIMEOUT seconds. The timer queue is the
|
|
* hash into which we sort timer entries.
|
|
*/
|
|
u_long current_time;
|
|
struct event timerqueue[TIMER_NSLOTS];
|
|
|
|
/*
|
|
* Stats. Number of overflows and number of calls to transmit().
|
|
*/
|
|
u_long timer_timereset;
|
|
u_long timer_overflows;
|
|
u_long timer_xmtcalls;
|
|
|
|
#ifndef SYS_WINNT
|
|
static RETSIGTYPE alarming P((int));
|
|
#else
|
|
void PASCAL alarming P((UINT,UINT,DWORD,DWORD,DWORD));
|
|
#endif /* SYS_WINNT */
|
|
|
|
#if defined(VMS)
|
|
static int vmstimer[2]; /* time for next timer AST */
|
|
static int vmsinc[2]; /* timer increment */
|
|
#endif /* VMS */
|
|
|
|
/*
|
|
* init_timer - initialize the timer data structures
|
|
*/
|
|
void
|
|
init_timer()
|
|
{
|
|
register int i;
|
|
#if !defined(VMS)
|
|
# ifndef SYS_WINNT
|
|
#ifndef HAVE_TIMER_SETTIME
|
|
struct itimerval itimer;
|
|
#else
|
|
static timer_t xntpd_timerid; /* should be global if we ever want to kill
|
|
timer without rebooting ... */
|
|
struct itimerspec itimer;
|
|
#endif
|
|
|
|
# else /* SYS_WINNT */
|
|
TIMECAPS tc;
|
|
HANDLE hToken;
|
|
TOKEN_PRIVILEGES tkp;
|
|
UINT wTimerRes, wTimerID;
|
|
extern HANDLE hMutex;
|
|
# endif /* SYS_WINNT */
|
|
#endif /* VMS */
|
|
|
|
/*
|
|
* Initialize...
|
|
*/
|
|
alarm_flag = 0;
|
|
alarm_overflow = 0;
|
|
adjust_timer = 1;
|
|
hourly_timer = HOUR;
|
|
current_time = 0;
|
|
timer_overflows = 0;
|
|
timer_xmtcalls = 0;
|
|
timer_timereset = 0;
|
|
|
|
for (i = 0; i < TIMER_NSLOTS; i++) {
|
|
/*
|
|
* Queue pointers should point at themselves. Event
|
|
* times must be set to 0 since this is used to
|
|
* detect the queue end.
|
|
*/
|
|
timerqueue[i].next = &timerqueue[i];
|
|
timerqueue[i].prev = &timerqueue[i];
|
|
timerqueue[i].event_time = 0;
|
|
}
|
|
|
|
#ifndef SYS_WINNT
|
|
/*
|
|
* Set up the alarm interrupt. The first comes 2**EVENT_TIMEOUT
|
|
* seconds from now and they continue on every 2**EVENT_TIMEOUT
|
|
* seconds.
|
|
*/
|
|
# if !defined(VMS)
|
|
#if defined(HAVE_TIMER_CREATE) && defined(HAVE_TIMER_SETTIME)
|
|
if (timer_create (CLOCK_REALTIME, NULL, &xntpd_timerid) ==
|
|
#ifdef SYS_VXWORKS
|
|
ERROR
|
|
#else
|
|
-1
|
|
#endif
|
|
)
|
|
{
|
|
fprintf (stderr, "timer create FAILED\n");
|
|
exit (0);
|
|
}
|
|
(void) signal_no_reset(SIGALRM, alarming);
|
|
itimer.it_interval.tv_sec = itimer.it_value.tv_sec = (1<<EVENT_TIMEOUT);
|
|
itimer.it_interval.tv_nsec = itimer.it_value.tv_nsec = 0;
|
|
timer_settime(xntpd_timerid, 0 /*!TIMER_ABSTIME*/, &itimer, NULL);
|
|
#else
|
|
(void) signal_no_reset(SIGALRM, alarming);
|
|
itimer.it_interval.tv_sec = itimer.it_value.tv_sec = (1<<EVENT_TIMEOUT);
|
|
itimer.it_interval.tv_usec = itimer.it_value.tv_usec = 0;
|
|
setitimer(ITIMER_REAL, &itimer, (struct itimerval *)0);
|
|
#endif
|
|
|
|
# else /* VMS */
|
|
vmsinc[0] = 10000000; /* 1 sec */
|
|
vmsinc[1] = 0;
|
|
lib$emul(&(1<<EVENT_TIMEOUT), &vmsinc, &0, &vmsinc);
|
|
|
|
sys$gettim(&vmstimer); /* that's "now" as abstime */
|
|
|
|
lib$addx(&vmsinc, &vmstimer, &vmstimer);
|
|
sys$setimr(0, &vmstimer, alarming, alarming, 0);
|
|
# endif /* VMS */
|
|
#else /* SYS_WINNT */
|
|
_tzset();
|
|
|
|
/*
|
|
* Get privileges needed for fiddling with the clock
|
|
*/
|
|
|
|
/* get the current process token handle */
|
|
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) {
|
|
msyslog(LOG_ERR, "OpenProcessToken failed: %m");
|
|
exit(1);
|
|
}
|
|
/* get the LUID for system-time privilege. */
|
|
LookupPrivilegeValue(NULL, SE_SYSTEMTIME_NAME, &tkp.Privileges[0].Luid);
|
|
tkp.PrivilegeCount = 1; /* one privilege to set */
|
|
tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
|
|
/* get set-time privilege for this process. */
|
|
AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES) NULL, 0);
|
|
/* cannot test return value of AdjustTokenPrivileges. */
|
|
if (GetLastError() != ERROR_SUCCESS)
|
|
msyslog(LOG_ERR, "AdjustTokenPrivileges failed: %m");
|
|
|
|
/*
|
|
* Set up timer interrupts for every 2**EVENT_TIMEOUT seconds
|
|
* Under Windows/NT, expiry of timer interval leads to invocation
|
|
* of a callback function (on a different thread) rather than
|
|
* generating an alarm signal
|
|
*/
|
|
|
|
/* determine max and min resolution supported */
|
|
if(timeGetDevCaps(&tc, sizeof(TIMECAPS)) != TIMERR_NOERROR) {
|
|
msyslog(LOG_ERR, "timeGetDevCaps failed: %m");
|
|
exit(1);
|
|
}
|
|
wTimerRes = min(max(tc.wPeriodMin, TARGET_RESOLUTION), tc.wPeriodMax);
|
|
/* establish the minimum timer resolution that we'll use */
|
|
timeBeginPeriod(wTimerRes);
|
|
|
|
hMutex = CreateMutex(
|
|
NULL, /* no security attributes */
|
|
FALSE, /* initially not owned */
|
|
"MutexForNTP"); /* name of mutex */
|
|
if (hMutex == NULL) {
|
|
msyslog(LOG_ERR, "cannot create a mutex: %m\n");
|
|
exit(1);
|
|
}
|
|
|
|
/* start the timer event */
|
|
wTimerID = timeSetEvent(
|
|
(1<<EVENT_TIMEOUT) * 1000, /* Delay in ms */
|
|
wTimerRes, /* Resolution */
|
|
(LPTIMECALLBACK) alarming, /* Callback function */
|
|
(DWORD) 0, /* User data */
|
|
TIME_PERIODIC); /* Event type (periodic) */
|
|
if (wTimerID == 0) {
|
|
msyslog(LOG_ERR, "timeSetEvent failed: %m");
|
|
exit(1);
|
|
}
|
|
#endif /* SYS_WINNT */
|
|
}
|
|
|
|
|
|
#ifdef TIMERQUEUE_DEBUG
|
|
/* Timer queue sanity checking routines */
|
|
|
|
static void EV_ASSERT(struct event *ev, char *m)
|
|
{
|
|
if ( ! ev )
|
|
{ msyslog(LOG_ERR, "%s is NULL, aborting!",m); abort(); }
|
|
}
|
|
|
|
static void EV_LINKCHK(struct event *ev, char *m)
|
|
{
|
|
if ( ! ev )
|
|
{ msyslog(LOG_ERR, "%s is NULL, aborting!",m); abort(); }
|
|
if ( ! ev->next )
|
|
{ msyslog(LOG_ERR, "%s->next is NULL, aborting!",m); abort(); }
|
|
if ( ! ev->prev )
|
|
{ msyslog(LOG_ERR, "%s->prev is NULL, aborting!",m); abort(); }
|
|
if ( ev->next->prev != ev )
|
|
{ msyslog(LOG_ERR, "%s->next->prev != self, aborting!",m); abort(); }
|
|
if ( ev->prev->next != ev )
|
|
{ msyslog(LOG_ERR, "%s->prev->next != self, aborting!",m); abort(); }
|
|
}
|
|
|
|
#else /* TIMERQUEUE_DEBUG */
|
|
|
|
# define EV_ASSERT() {}
|
|
# define EV_LINKCHK() {}
|
|
|
|
#endif /* TIMERQUEUE_DEBUG */
|
|
|
|
/*
|
|
* timer - dispatch anyone who needs to be
|
|
*/
|
|
void
|
|
timer()
|
|
{
|
|
register struct event *ev;
|
|
register struct event *tq;
|
|
#ifdef SYS_WINNT
|
|
extern HANDLE hMutex;
|
|
#endif
|
|
|
|
current_time += (1<<EVENT_TIMEOUT);
|
|
|
|
/*
|
|
* Adjustment timeout first
|
|
*/
|
|
if (adjust_timer <= current_time) {
|
|
adjust_timer += 1;
|
|
adj_host_clock();
|
|
}
|
|
|
|
#ifdef SYS_WINNT
|
|
if (!ReleaseMutex(hMutex)) {
|
|
msyslog(LOG_ERR, "alarming cannot release mutex: %m\n");
|
|
exit(1);
|
|
}
|
|
#endif /* SYS_WINNT */
|
|
|
|
/*
|
|
* Leap timer next.
|
|
*/
|
|
if (leap_timer != 0 && leap_timer <= current_time)
|
|
leap_process();
|
|
|
|
/*
|
|
* Now dispatch any peers whose event timer has expired.
|
|
*/
|
|
|
|
/* Added mutex to prevent race condition among threads under Windows NT */
|
|
#ifdef SYS_WINNT
|
|
WaitForSingleObject(m_hListMutex,INFINITE);
|
|
#endif /* SYS_WINNT */
|
|
|
|
#ifdef TIMERQUEUE_DEBUG
|
|
{
|
|
int i;
|
|
int j;
|
|
|
|
for (i = 0; i < TIMER_NSLOTS; ++i)
|
|
{
|
|
struct event *qh;
|
|
|
|
qh = ev = &timerqueue[i];
|
|
if (qh->event_time != 0) {
|
|
msyslog(LOG_ERR, "timerqueue[%d].event_time is %d instead of 0!",
|
|
i, timerqueue[i].event_time);
|
|
abort();
|
|
}
|
|
j = 0;
|
|
do
|
|
{
|
|
if (ev->prev->next != ev) {
|
|
msyslog(LOG_ERR, "timerqueue[%d]: #%d: ev->prev->next != ev",
|
|
i, j);
|
|
abort();
|
|
}
|
|
if (ev->next->prev != ev) {
|
|
msyslog(LOG_ERR, "timerqueue[%d]: #%d: ev->next->prev != ev",
|
|
i, j);
|
|
abort();
|
|
}
|
|
++j;
|
|
ev = ev->next;
|
|
}
|
|
while (qh != ev);
|
|
}
|
|
}
|
|
#endif /* TIMERQUEUE_DEBUG */
|
|
|
|
tq = &timerqueue[TIMER_SLOT(current_time)];
|
|
if (tq) {
|
|
ev = tq->next;
|
|
while (ev
|
|
&& ev->event_time != 0
|
|
&& ev->event_time < (current_time + (1<<EVENT_TIMEOUT))) {
|
|
tq->next = ev->next;
|
|
tq->next->prev = tq;
|
|
ev->prev = ev->next = 0;
|
|
timer_xmtcalls++;
|
|
ev->event_handler(ev->peer);
|
|
ev = tq->next;
|
|
}
|
|
if (!ev) {
|
|
msyslog(LOG_ERR, "timer: ev was NIL!");
|
|
abort();
|
|
}
|
|
} else {
|
|
msyslog(LOG_ERR, "timer: tq was NIL!");
|
|
abort();
|
|
}
|
|
|
|
/* Added mutex to prevent race condition among threads under Windows NT */
|
|
#ifdef SYS_WINNT
|
|
ReleaseMutex(m_hListMutex);
|
|
#endif /* SYS_WINNT */
|
|
|
|
/*
|
|
* Finally, call the hourly routine
|
|
*/
|
|
if (hourly_timer <= current_time) {
|
|
hourly_timer += HOUR;
|
|
hourly_stats();
|
|
}
|
|
}
|
|
|
|
|
|
#ifndef SYS_WINNT
|
|
/*
|
|
* alarming - tell the world we've been alarmed
|
|
*/
|
|
static RETSIGTYPE
|
|
alarming(sig)
|
|
int sig;
|
|
{
|
|
extern int initializing; /* from main line code */
|
|
|
|
#if !defined(VMS)
|
|
if (initializing)
|
|
return;
|
|
if (alarm_flag)
|
|
alarm_overflow++;
|
|
else
|
|
alarm_flag++;
|
|
#else /* VMS AST routine */
|
|
if (!initializing) {
|
|
if (alarm_flag) alarm_overflow++;
|
|
else alarm_flag = 1; /* increment is no good */
|
|
}
|
|
lib$addx(&vmsinc,&vmstimer,&vmstimer);
|
|
sys$setimr(0,&vmstimer,alarming,alarming,0);
|
|
#endif /* VMS */
|
|
}
|
|
#else /* SYS_WINNT */
|
|
/*
|
|
* alarming for WinNT - invoke the timer() routine after grabbing the mutex
|
|
*/
|
|
void PASCAL alarming (UINT wTimerID, UINT msg,
|
|
DWORD dwUser, DWORD dw1, DWORD dw2)
|
|
{
|
|
extern int debug;
|
|
static int initializing2 = 1;
|
|
extern HANDLE hMutex;
|
|
DWORD dwWaitResult;
|
|
extern HANDLE TimerThreadHandle;
|
|
static DWORD threadID;
|
|
#ifdef DEBUG
|
|
SYSTEMTIME st;
|
|
#endif
|
|
|
|
/*
|
|
* set the priority for timer() thread to be higher than the main thread
|
|
*/
|
|
if (initializing2) {
|
|
TimerThreadHandle = GetCurrentThread();
|
|
if (!SetThreadPriority(TimerThreadHandle, (DWORD) THREAD_PRIORITY_HIGHEST))
|
|
msyslog(LOG_ERR, "SetThreadPriority failed: %m");
|
|
threadID = GetCurrentThreadId();
|
|
initializing2 = 0;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
if (debug > 9) {
|
|
GetSystemTime(&st);
|
|
printf("thread %u (timer callback): time %02u:%02u:%02u:%03u\n",
|
|
threadID, st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
|
|
fflush(stdout);
|
|
}
|
|
#endif
|
|
|
|
dwWaitResult = WaitForSingleObject(
|
|
hMutex, /* handle of mutex */
|
|
5000L); /* five-second time-out interval */
|
|
|
|
switch (dwWaitResult) {
|
|
case WAIT_OBJECT_0:
|
|
/* The thread got mutex ownership. */
|
|
/* the mutex is released in the timer() routine */
|
|
timer();
|
|
break;
|
|
default:
|
|
/* Cannot get mutex ownership due to time-out. */
|
|
msyslog(LOG_ERR, "alarming error with mutex: %m\n");
|
|
exit(1);
|
|
}
|
|
|
|
UNREFERENCED_PARAMETER(dw1);
|
|
UNREFERENCED_PARAMETER(dw2);
|
|
UNREFERENCED_PARAMETER(dwUser);
|
|
UNREFERENCED_PARAMETER(msg);
|
|
UNREFERENCED_PARAMETER(wTimerID);
|
|
}
|
|
#endif /* SYS_WINNT */
|
|
|
|
|
|
/*
|
|
* timer_clr_stats - clear timer module stat counters
|
|
*/
|
|
void
|
|
timer_clr_stats()
|
|
{
|
|
timer_overflows = 0;
|
|
timer_xmtcalls = 0;
|
|
timer_timereset = current_time;
|
|
}
|
|
|
|
|
|
#ifdef TIMERQUEUE_DEBUG
|
|
/* macro versions of these routines are available in include/ntp.h */
|
|
|
|
# ifdef SYS_WINNT /* WindowsNT apparently needs mutex locking around here */
|
|
# define WINNT_WAIT() WaitForSingleObject(m_hListMutex,INFINITE)
|
|
# define WINNT_RELS() ReleaseMutex(m_hListMutex)
|
|
# else
|
|
# define WINNT_WAIT() {}
|
|
# define WINNT_RELS() {}
|
|
# endif
|
|
|
|
/*
|
|
* TIMER_ENQUEUE() puts stuff on the timer queue. It takes as
|
|
* arguments (ea), an array of event slots, and (iev), the event
|
|
* to be inserted. This one searches the hash bucket from the
|
|
* end, and is about optimum for the timing requirements of
|
|
* NTP peers.
|
|
*/
|
|
void TIMER_ENQUEUE(struct event *ea, struct event *iev)
|
|
{
|
|
register struct event *ev;
|
|
|
|
EV_LINKCHK( ea, "TIMER_ENQUEUE(): ea" );
|
|
EV_ASSERT( iev, "TIMER_ENQUEUE(): iev" );
|
|
WINNT_WAIT();
|
|
ev = (ea)[TIMER_SLOT((iev)->event_time)].prev;
|
|
EV_LINKCHK( ev, "TIMER_ENQUEUE(): ev" );
|
|
while (ev->event_time > (iev)->event_time) {
|
|
ev = ev->prev;
|
|
EV_LINKCHK( ev, "TIMER_ENQUEUE(): ev" );
|
|
}
|
|
(iev)->prev = ev;
|
|
(iev)->next = ev->next;
|
|
(ev)->next->prev = (iev);
|
|
(ev)->next = (iev);
|
|
WINNT_RELS();
|
|
}
|
|
|
|
/*
|
|
* TIMER_INSERT() also puts stuff on the timer queue, but searches the
|
|
* bucket from the top. This is better for things that do very short
|
|
* time outs, like clock support.
|
|
*/
|
|
void TIMER_INSERT(struct event *ea, struct event *iev)
|
|
{
|
|
register struct event *ev;
|
|
|
|
EV_LINKCHK( ea, "TIMER_INSERT(): ea" );
|
|
EV_ASSERT( iev, "TIMER_INSERT(): iev" );
|
|
WINNT_WAIT();
|
|
ev = (ea)[TIMER_SLOT((iev)->event_time)].next;
|
|
EV_LINKCHK( ev, "TIMER_INSERT(): ev" );
|
|
while (ev->event_time != 0 &&
|
|
ev->event_time < (iev)->event_time) {
|
|
ev = ev->next;
|
|
EV_LINKCHK( ev, "TIMER_INSERT(): ev" );
|
|
}
|
|
(iev)->next = ev;
|
|
(iev)->prev = ev->prev;
|
|
(ev)->prev->next = (iev);
|
|
(ev)->prev = (iev);
|
|
WINNT_RELS();
|
|
}
|
|
|
|
/*
|
|
* Remove an event from the queue.
|
|
*/
|
|
void TIMER_DEQUEUE(struct event *ev)
|
|
{
|
|
EV_ASSERT( ev, "TIMER_DEQUEUE(): ev" );
|
|
WINNT_WAIT();
|
|
if ((ev)->next != 0) {
|
|
EV_LINKCHK( ev, "TIMER_DEQUEUE(): ev" );
|
|
(ev)->next->prev = (ev)->prev;
|
|
(ev)->prev->next = (ev)->next;
|
|
(ev)->next = (ev)->prev = 0;
|
|
}
|
|
WINNT_RELS();
|
|
}
|
|
|
|
#endif /* TIMERQUEUE_DEBUG */
|