dark0707
/
px4-firmware
forked from Archive/PX4-Autopilot
1
0
Fork 0
Code Pull Requests Activity
px4-firmware/apps/netutils/thttpd/timers.c

366 lines
8.7 KiB
C
Raw Blame History

/****************************************************************************
* netutils/thttpd/timers.c
* Simple Timer Routines
*
* Copyright (C) 2009 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* Derived from the file of the same name in the original THTTPD package:
*
* Copyright © 1995,1998,2000 by Jef Poskanzer <jef@mail.acme.com>.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <sys/time.h>
#include <stdlib.h>
#include <stdio.h>
#include <debug.h>
#include "thttpd_alloc.h"
#include "timers.h"
/****************************************************************************
* Pre-Processor Definitons
****************************************************************************/
#define HASH_SIZE 67
/****************************************************************************
* Private Data
****************************************************************************/
static Timer *timers[HASH_SIZE];
static Timer *free_timers;
/****************************************************************************
* Public Data
****************************************************************************/
ClientData JunkClientData;
/****************************************************************************
* Private Functions
****************************************************************************/
static unsigned int hash(Timer *tmr)
{
/* We can hash on the trigger time, even though it can change over the
* life of a timer via the periodic bit.
* This is because both of those guys call l_resort(), which * recomputes
* the hash and moves the timer to the appropriate list.
*/
return ((unsigned int)tmr->time.tv_sec ^
(unsigned int)tmr->time.tv_usec) % HASH_SIZE;
}
static void l_add(Timer *tmr)
{
int h = tmr->hash;
register Timer *tmr2;
register Timer *tmr2prev;
tmr2 = timers[h];
if (tmr2 == NULL)
{
/* The list is empty. */
timers[h] = tmr;
tmr->prev = tmr->next = NULL;
}
else
{
if (tmr->time.tv_sec < tmr2->time.tv_sec ||
(tmr->time.tv_sec == tmr2->time.tv_sec &&
tmr->time.tv_usec <= tmr2->time.tv_usec))
{
/* The new timer goes at the head of the list. */
timers[h] = tmr;
tmr->prev = NULL;
tmr->next = tmr2;
tmr2->prev = tmr;
}
else
{
/* Walk the list to find the insertion point. */
for (tmr2prev = tmr2, tmr2 = tmr2->next; tmr2 != NULL;
tmr2prev = tmr2, tmr2 = tmr2->next)
{
if (tmr->time.tv_sec < tmr2->time.tv_sec ||
(tmr->time.tv_sec == tmr2->time.tv_sec &&
tmr->time.tv_usec <= tmr2->time.tv_usec))
{
/* Found it. */
tmr2prev->next = tmr;
tmr->prev = tmr2prev;
tmr->next = tmr2;
tmr2->prev = tmr;
return;
}
}
/* Oops, got to the end of the list. Add to tail. */
tmr2prev->next = tmr;
tmr->prev = tmr2prev;
tmr->next = NULL;
}
}
}
static void l_remove(Timer *tmr)
{
int h = tmr->hash;
if (tmr->prev == NULL)
{
timers[h] = tmr->next;
}
else
{
tmr->prev->next = tmr->next;
}
if (tmr->next != NULL)
{
tmr->next->prev = tmr->prev;
}
}
static void l_resort(Timer *tmr)
{
/* Remove the timer from its old list. */
l_remove(tmr);
/* Recompute the hash. */
tmr->hash = hash(tmr);
/* And add it back in to its new list, sorted correctly. */
l_add(tmr);
}
/****************************************************************************
* Public Functions
****************************************************************************/
void tmr_init(void)
{
int h;
for (h = 0; h < HASH_SIZE; ++h)
{
timers[h] = NULL;
}
free_timers = NULL;
}
Timer *tmr_create(struct timeval *now, TimerProc *timer_proc,
ClientData client_data, long msecs, int periodic)
{
Timer *tmr;
if (free_timers != NULL)
{
tmr = free_timers;
free_timers = tmr->next;
}
else
{
tmr = (Timer*)httpd_malloc(sizeof(Timer));
if (!tmr)
{
return NULL;
}
}
tmr->timer_proc = timer_proc;
tmr->client_data = client_data;
tmr->msecs = msecs;
tmr->periodic = periodic;
if (now != NULL)
{
tmr->time = *now;
}
else
{
(void)gettimeofday(&tmr->time, NULL);
}
tmr->time.tv_sec += msecs / 1000L;
tmr->time.tv_usec += (msecs % 1000L) * 1000L;
if (tmr->time.tv_usec >= 1000000L)
{
tmr->time.tv_sec += tmr->time.tv_usec / 1000000L;
tmr->time.tv_usec %= 1000000L;
}
tmr->hash = hash(tmr);
/* Add the new timer to the proper active list. */
l_add(tmr);
return tmr;
}
long tmr_mstimeout(struct timeval *now)
{
int h;
int gotone;
long msecs, m;
register Timer *tmr;
gotone = 0;
msecs = 0;
/* Since the lists are sorted, we only need to look at the * first timer on
* each one.
*/
for (h = 0; h < HASH_SIZE; ++h)
{
tmr = timers[h];
if (tmr != NULL)
{
m = (tmr->time.tv_sec - now->tv_sec) * 1000L +
(tmr->time.tv_usec - now->tv_usec) / 1000L;
if (!gotone)
{
msecs = m;
gotone = 1;
}
else if (m < msecs)
{
msecs = m;
}
}
}
if (!gotone)
{
return INFTIM;
}
if (msecs <= 0)
{
msecs = 0;
}
return msecs;
}
void tmr_run(struct timeval *now)
{
int h;
Timer *tmr;
Timer *next;
for (h = 0; h < HASH_SIZE; ++h)
{
for (tmr = timers[h]; tmr != NULL; tmr = next)
{
next = tmr->next;
/* Since the lists are sorted, as soon as we find a timer * that isn'tmr
* ready yet, we can go on to the next list
*/
if (tmr->time.tv_sec > now->tv_sec ||
(tmr->time.tv_sec == now->tv_sec && tmr->time.tv_usec > now->tv_usec))
{
break;
}
(tmr->timer_proc)(tmr->client_data, now);
if (tmr->periodic)
{
/* Reschedule. */
tmr->time.tv_sec += tmr->msecs / 1000L;
tmr->time.tv_usec += (tmr->msecs % 1000L) * 1000L;
if (tmr->time.tv_usec >= 1000000L)
{
tmr->time.tv_sec += tmr->time.tv_usec / 1000000L;
tmr->time.tv_usec %= 1000000L;
}
l_resort(tmr);
}
else
{
tmr_cancel(tmr);
}
}
}
}
void tmr_cancel(Timer *tmr)
{
/* Remove it from its active list. */
l_remove(tmr);
/* And put it on the free list. */
tmr->next = free_timers;
free_timers = tmr;
tmr->prev = NULL;
}
void tmr_cleanup(void)
{
Timer *tmr;
while (free_timers != NULL)
{
tmr = free_timers;
free_timers = tmr->next;
httpd_free((void*)tmr);
}
}
void tmr_destroy(void)
{
int h;
for (h = 0; h < HASH_SIZE; ++h)
{
while (timers[h] != NULL)
{
tmr_cancel(timers[h]);
}
}
tmr_cleanup();
}
View Git Blame Copy Permalink