sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Remove last remnants of SYLOGging

Browse Source 
git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@2043 42af7a65-404d-4744-a932-0658087f49c3
This commit is contained in:
patacongo 2009-09-13 00:12:09 +00:00
parent 91b95bbc61
commit 415d05f6ea
9 changed files with 81 additions and 259 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
netutils/thttpd/fdwatch.c
View File

@ -64,10 +64,6 @@
* Private Data
****************************************************************************/
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
static long nwatches = 0;
#endif
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
@ -259,10 +255,6 @@ int fdwatch(struct fdwatch_s *fw, long timeout_msecs)
int ret;
int i;
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
nwatches++;
#endif
/* Wait for activity on any of the desciptors. When poll() returns, ret
* will hold the number of descriptors with activity (or zero on a timeout
* or <0 on an error.
@ -344,19 +336,5 @@ void *fdwatch_get_next_client_data(struct fdwatch_s *fw)
return fw->client[fw->next++];
}
/* Generate debugging statistics ndbg message. */
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
void fdwatch_logstats(struct fdwatch_s *fw, long secs)
{
fdwatch_dump("LOG stats:", fw);
if (secs > 0)
{
ndbg("fdwatch - %ld polls (%g/sec)\n", nwatches, (float)nwatches / secs);
}
nwatches = 0;
}
#endif
#endif /* CONFIG_THTTPD */

6
netutils/thttpd/fdwatch.h
View File

@ -107,11 +107,5 @@ extern int fdwatch_check_fd(struct fdwatch_s *fw, int fd);
extern void *fdwatch_get_next_client_data(struct fdwatch_s *fw);
/* Generate debugging statistics syslog message. */
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
extern void fdwatch_logstats(struct fdwatch_s *fw, long secs);
#endif
#endif /* __NETUTILS_THTTPD_FDWATCH_H */

68
netutils/thttpd/httpd_alloc.c
View File

@ -65,16 +65,41 @@
* Private Data
****************************************************************************/
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
#ifdef CONFIG_THTTPD_MEMDEBUG
static int g_nallocations = 0;
static size_t g_allocated = 0;
#endif
/****************************************************************************
* Private Functions
****************************************************************************/
/* Generate debugging statistics */
#ifdef CONFIG_THTTPD_MEMDEBUG
void httpd_memstats(void)
{
static struct mallinfo mm;
ndbg("%d allocations (%lu bytes)\n", g_nallocations, (unsigned long)g_allocated);
/* Get the current memory usage */
#ifdef CONFIG_CAN_PASS_STRUCTS
mm = mallinfo();
#else
(void)mallinfo(&mm);
#endif
ndbg("arena: %08x ordblks: %08x mxordblk: %08x uordblks: %08x fordblks: %08x\n",
mm.arena, mm.ordblks, mm.mxordblk, mm.uordblks, mm.fordblks);
}
#endif
/****************************************************************************
* Global Functions
****************************************************************************/
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
#ifdef CONFIG_THTTPD_MEMDEBUG
FAR void *httpd_malloc(size_t nbytes)
{
void *ptr = malloc(nbytes);
@ -84,20 +109,16 @@ FAR void *httpd_malloc(size_t nbytes)
}
else
{
#ifdef CONFIG_THTTPD_MEMDEBUG
nvdbg("Allocated %d bytes at %p\n", nbytes, ptr);
#endif
g_nallocations++;
g_allocated += nbytes;
}
#ifdef CONFIG_THTTPD_MEMDEBUG
httpd_memstats();
#endif
return ptr;
}
#endif
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
#ifdef CONFIG_THTTPD_MEMDEBUG
FAR void *httpd_realloc(FAR void *oldptr, size_t oldsize, size_t newsize)
{
void *ptr = realloc(oldptr, newsize);
@ -108,27 +129,21 @@ FAR void *httpd_realloc(FAR void *oldptr, size_t oldsize, size_t newsize)
}
else
{
#ifdef CONFIG_THTTPD_MEMDEBUG
nvdbg("Re-allocated form %d to %d bytes (from %p to %p)\n",
oldsize, newsize, oldptr, ptr);
#endif
g_allocated += (newsize - oldsize);
}
#ifdef CONFIG_THTTPD_MEMDEBUG
httpd_memstats();
#endif
return ptr;
}
#endif
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
#ifdef CONFIG_THTTPD_MEMDEBUG
void httpd_free(FAR void *ptr)
{
free(ptr);
#ifdef CONFIG_THTTPD_MEMDEBUG
nvdbg("Freed memory at %p\n", ptr);
httpd_memstats();
#endif
}
#endif
@ -160,29 +175,4 @@ void httpd_realloc_str(char **pstr, size_t *maxsize, size_t size)
}
}
/* Generate debugging statistics */
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
void httpd_memstats(void)
{
#ifdef CONFIG_THTTPD_MEMDEBUG
static struct mallinfo mm;
#endif
ndbg("%d allocations (%lu bytes)\n", g_nallocations, (unsigned long)g_allocated);
/* Get the current memory usage */
#ifdef CONFIG_THTTPD_MEMDEBUG
#ifdef CONFIG_CAN_PASS_STRUCTS
mm = mallinfo();
#else
(void)mallinfo(&mm);
#endif
ndbg("arena: %08x ordblks: %08x mxordblk: %08x uordblks: %08x fordblks: %08x\n",
mm.arena, mm.ordblks, mm.mxordblk, mm.uordblks, mm.fordblks);
#endif
}
#endif
#endif /* CONFIG_THTTPD */

10
netutils/thttpd/httpd_alloc.h
View File

@ -51,7 +51,7 @@
/* Allows all memory management calls to be intercepted */
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
#ifdef CONFIG_THTTPD_MEMDEBUG
extern FAR void *httpd_malloc(size_t nbytes);
extern FAR void *httpd_realloc(FAR void *oldptr, size_t oldsize, size_t newsize);
extern void httpd_free(FAR void *ptr);
@ -70,13 +70,5 @@ extern void httpd_free(FAR void *ptr);
extern void httpd_realloc_str(char **pstr, size_t *maxsizeP, size_t size);
/* Generate debugging statistics */
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
extern void httpd_memstats(void);
#else
# define httpd_memstats()
#endif
#endif /* CONFIG_THTTPD */
#endif /* __NETUTILS_THTTPD_HTTDP_ALLOC_H */

71
netutils/thttpd/libhttpd.c
View File

@ -213,11 +213,11 @@ static size_t sockaddr_len(httpd_sockaddr *saP);
* Private Data
****************************************************************************/
/* This global keeps track of whether we are in the main process or a
* sub-process. The reason is that httpd_write_response() can get called
* in either context; when it is called from the main process it must use
/* This global keeps track of whether we are in the main task or a
* sub-task. The reason is that httpd_write_response() can get called
* in either context; when it is called from the main task it must use
* non-blocking I/O to avoid stalling the server, but when it is called
* from a sub-process it wants to use blocking I/O so that the whole
* from a sub-task it wants to use blocking I/O so that the whole
* response definitely gets written. So, it checks this variable. A bit
* of a hack but it seems to do the right thing.
*/
@ -1696,7 +1696,7 @@ static void cgi_kill2(ClientData client_data, struct timeval *nowP)
pid = (pid_t) client_data.i;
if (kill(pid, SIGKILL) == 0)
{
ndbg("hard-killed CGI process %d\n", pid);
ndbg("hard-killed CGI task %d\n", pid);
}
}
@ -1707,7 +1707,7 @@ static void cgi_kill(ClientData client_data, struct timeval *nowP)
pid = (pid_t) client_data.i;
if (kill(pid, SIGINT) == 0)
{
ndbg("killed CGI process %d\n", pid);
ndbg("killed CGI task %d\n", pid);
/* In case this isn't enough, schedule an uncatchable kill. */
@ -1764,7 +1764,7 @@ static void ls_child(int argc, char **argv)
/* Open a stdio stream so that we can use fprintf, which is more
* efficient than a bunch of separate write()s. We don't have to
* worry about double closes or file descriptor leaks cause we're
* in a subprocess.
* in a sub-task.
*/
fp = fdopen(hc->conn_fd, "w");
@ -2065,9 +2065,9 @@ static int ls(httpd_conn *hc)
}
closedir(dirp);
ndbg("spawned indexing process %d for directory '%s'\n", child, hc->expnfilename);
ndbg("spawned indexing task %d for directory '%s'\n", child, hc->expnfilename);
/* Schedule a kill for the child process, in case it runs too long */
/* Schedule a kill for the child task, in case it runs too long */
#if CONFIG_THTTPD_CGI_TIMELIMIT > 0
client_data.i = child;
@ -2096,7 +2096,7 @@ static int ls(httpd_conn *hc)
/* Set up environment variables. Be real careful here to avoid
* letting malicious clients overrun a buffer. We don't have
* to worry about freeing stuff since we're a sub-process.
* to worry about freeing stuff since we're a sub-task.
*/
#ifdef CONFIG_THTTPD_CGI_PATTERN
@ -2343,10 +2343,10 @@ static inline int cgi_interpose_input(httpd_conn *hc, int wfd, char *buffer)
/* Special hack to deal with broken browsers that send a LF or CRLF
* after POST data, causing TCP resets - we just read and discard up
* to 2 bytes. Unfortunately this doesn't fix the problem for CGIs
* which avoid the interposer process due to their POST data being
* short. Creating an interposer process for all POST CGIs is
* which avoid the interposer task due to their POST data being
* short. Creating an interposer task for all POST CGIs is
* unacceptably expensive. The eventual fix will come when interposing
* gets integrated into the main loop as a tasklet instead of a process.
* gets integrated into the main loop as a tasklet instead of a task.
*/
/* Turn on no-delay mode in case we previously cleared it. */
@ -2620,7 +2620,7 @@ static inline int cgi_interpose_output(httpd_conn *hc, int rfd, char *inbuffer,
}
#endif
/* CGI child process. */
/* CGI child task. */
#ifdef CONFIG_THTTPD_CGI_PATTERN
static int cgi_child(int argc, char **argv)
@ -2645,6 +2645,12 @@ static int cgi_child(int argc, char **argv)
int ret;
int err = 1;
/* Use low-level debug out (because the low-level output may survive closing
* all file descriptors
*/
nllvdbg("Started: %s\n", argv[1]);
/* Update all of the environment variable settings, these will be inherited
* by the CGI task.
*/
@ -2659,6 +2665,7 @@ static int cgi_child(int argc, char **argv)
* stderr and hc->conn_fd
*/
nllvdbg("Closing all descriptors\n");
for (fd = 0; fd < (CONFIG_NFILE_DESCRIPTORS + CONFIG_NSOCKET_DESCRIPTORS); fd++)
{
/* Keep stderr open for debug; keep hc->conn_fd open for obvious reasons */
@ -2672,15 +2679,15 @@ static int cgi_child(int argc, char **argv)
/* Create pipes that will be interposed between the CGI task's stdin or
* stdout and the socket.
*
*
* Setup up the STDIN pipe - a pipe to transfer data received on the
* socket to the CGI program.
*/
nllvdbg("Create STDIN pipe\n");
ret = pipe(pipefd);
if (ret < 0)
{
ndbg("STDIN pipe: %d\n", errno);
nlldbg("STDIN pipe: %d\n", errno);
goto errout_with_descriptors;
}
else
@ -2692,7 +2699,7 @@ static int cgi_child(int argc, char **argv)
ret = dup2(pipefd[0], 0);
if (ret < 0)
{
ndbg("STDIN dup2: %d\n", errno);
nlldbg("STDIN dup2: %d\n", errno);
close(pipefd[1]);
goto errout_with_descriptors;
}
@ -2707,10 +2714,11 @@ static int cgi_child(int argc, char **argv)
if (ret == 0)
{
nllvdbg("Create STDOUT pipe\n");
ret = pipe(pipefd);
if (ret < 0)
{
ndbg("STDOUT pipe: %d\n", errno);
nlldbg("STDOUT pipe: %d\n", errno);
goto errout_with_descriptors;
}
else
@ -2722,10 +2730,10 @@ static int cgi_child(int argc, char **argv)
ret = dup2(pipefd[1], 1);
if (ret < 0)
{
ndbg("STDOUT dup2: %d\n", errno);
nlldbg("STDOUT dup2: %d\n", errno);
close(pipefd[1]);
goto errout_with_descriptors;
}
}
rfd = pipefd[0];
close(pipefd[1]);
@ -2762,14 +2770,14 @@ static int cgi_child(int argc, char **argv)
httpd_realloc_str(&hdr.buffer, &hdr.size, 500);
if (!hdr.buffer)
{
ndbg("hdr allocation failed\n");
nlldbg("hdr allocation failed\n");
goto errout_with_descriptors;
}
buffer = (char*)httpd_malloc(CONFIG_THTTPD_IOBUFFERSIZE);
if (!buffer)
{
ndbg("buffer allocation failed\n");
nlldbg("buffer allocation failed\n");
goto errout_with_header;
}
@ -2778,28 +2786,29 @@ static int cgi_child(int argc, char **argv)
fw = fdwatch_initialize(2);
if (!fw)
{
ndbg("fdwatch allocation failed\n");
nlldbg("fdwatch allocation failed\n");
goto errout_with_buffer;
}
/* Run the CGI program. */
nllvdbg("Starting CGI\n");
child = exec(binary, (FAR const char **)argp, g_thttpdsymtab, g_thttpdnsymbols);
if (child < 0)
{
/* Something went wrong. */
ndbg("execve %s: %d\n", hc->expnfilename, errno);
nlldbg("execve %s: %d\n", hc->expnfilename, errno);
goto errout_with_watch;
}
/* Schedule a kill for the child process, in case it runs too long. */
/* Schedule a kill for the child task in case it runs too long. */
#if CONFIG_THTTPD_CGI_TIMELIMIT > 0
client_data.i = child;
if (tmr_create(NULL, cgi_kill, client_data, CONFIG_THTTPD_CGI_TIMELIMIT * 1000L, 0) == NULL)
{
ndbg("tmr_create(cgi_kill child) failed\n");
nlldbg("tmr_create(cgi_kill child) failed\n");
goto errout_with_watch;
}
#endif
@ -2814,6 +2823,7 @@ static int cgi_child(int argc, char **argv)
indone = FALSE;
outdone = FALSE;
nllvdbg("Interposing\n");
do
{
(void)fdwatch(fw, 5000);
@ -2822,6 +2832,7 @@ static int cgi_child(int argc, char **argv)
{
/* Transfer data from the client to the CGI program (POST) */
nllvdbg("Interpose input\n");
indone = cgi_interpose_input(hc, wfd, buffer);
if (indone)
{
@ -2833,6 +2844,7 @@ static int cgi_child(int argc, char **argv)
{
/* Handle receipt of headers and CGI program response (GET) */
nllvdbg("Interpose output\n");
outdone = cgi_interpose_output(hc, rfd, buffer, &hdr);
}
}
@ -2861,6 +2873,7 @@ errout_with_descriptors:
INTERNALERROR("errout");
httpd_send_err(hc, 500, err500title, "", err500form, hc->encodedurl);
httpd_write_response(hc);
nllvdbg("Return %d\n", ret);
return err;
}
#endif /* CONFIG_THTTPD_CGI_PATTERN */
@ -2909,7 +2922,7 @@ static int cgi(httpd_conn *hc)
return -1;
}
ndbg("started CGI process %d for file '%s'\n", child, hc->expnfilename);
ndbg("Started CGI task %d for file '%s'\n", child, hc->expnfilename);
hc->status = 200;
hc->bytes_sent = CONFIG_THTTPD_CGI_BYTECOUNT;
@ -3184,7 +3197,7 @@ void httpd_unlisten(httpd_server * hs)
void httpd_write_response(httpd_conn *hc)
{
/* If we are in a sub-process, turn off no-delay mode. */
/* If we are in a sub-task, turn off no-delay mode. */
if (main_thread != getpid())
{
@ -4108,7 +4121,7 @@ int httpd_parse_request(httpd_conn *hc)
return 0;
}
void httpd_close_conn(httpd_conn *hc, struct timeval *nowP)
void httpd_close_conn(httpd_conn *hc)
{
if (hc->file_fd >= 0)
{

6
netutils/thttpd/libhttpd.h
View File

@ -296,11 +296,9 @@ extern int httpd_start_request(httpd_conn *hc, struct timeval *nowP);
extern void httpd_write_response(httpd_conn *hc);
/* Call this to close down a connection and free the data.
* If you don't have a current timeval handy just pass in 0.
*/
/* Call this to close down a connection and free the data. */
extern void httpd_close_conn(httpd_conn *hc, struct timeval *nowP);
extern void httpd_close_conn(httpd_conn *hc);
/* Call this to de-initialize a connection struct and *really* free the
* mallocced strings.

102
netutils/thttpd/thttpd.c
View File

@ -112,13 +112,6 @@ static struct fdwatch_s *fw;
* Public Data
****************************************************************************/
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
time_t start_time;
time_t stats_time;
long stats_connections;
off_t stats_bytes;
#endif
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
@ -130,19 +123,11 @@ static void handle_send(struct connect_s *conn, struct timeval *tv);
static void handle_linger(struct connect_s *conn, struct timeval *tv);
static void finish_connection(struct connect_s *conn, struct timeval *tv);
static void clear_connection(struct connect_s *conn, struct timeval *tv);
static void really_clear_connection(struct connect_s *conn, struct timeval *tv);
static void really_clear_connection(struct connect_s *conn);
static void idle(ClientData client_data, struct timeval *nowP);
static void linger_clear_connection(ClientData client_data, struct timeval *nowP);
static void occasional(ClientData client_data, struct timeval *nowP);
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
static void logstats(struct timeval *nowP);
static void thttpd_logstats(long secs);
#else
# define logstats(nowP)
# define thttpd_logstats(secs)
#endif
/****************************************************************************
* Private Functions
****************************************************************************/
@ -150,15 +135,12 @@ static void thttpd_logstats(long secs);
static void shut_down(void)
{
int cnum;
struct timeval tv;
(void)gettimeofday(&tv, NULL);
logstats(&tv);
for (cnum = 0; cnum < AVAILABLE_FDS; ++cnum)
{
if (connects[cnum].conn_state != CNST_FREE)
{
httpd_close_conn(connects[cnum].hc, &tv);
httpd_close_conn(connects[cnum].hc);
}
if (connects[cnum].hc != NULL)
@ -267,10 +249,6 @@ static int handle_newconnect(struct timeval *tv, int listen_fd)
httpd_set_ndelay(conn->hc->conn_fd);
fdwatch_add_fd(fw, conn->hc->conn_fd, conn);
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
++stats_connections;
#endif
}
}
@ -520,7 +498,7 @@ static void handle_linger(struct connect_s *conn, struct timeval *tv)
if (ret <= 0)
{
really_clear_connection(conn, tv);
really_clear_connection(conn);
}
}
@ -583,17 +561,13 @@ static void clear_connection(struct connect_s *conn, struct timeval *tv)
/* Either we are done lingering, we shouldn't linger, or we failed to setup the linger */
really_clear_connection(conn, tv);
really_clear_connection(conn);
}
static void really_clear_connection(struct connect_s *conn, struct timeval *tv)
static void really_clear_connection(struct connect_s *conn)
{
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
stats_bytes += conn->hc->bytes_sent;
#endif
fdwatch_del_fd(fw, conn->hc->conn_fd);
httpd_close_conn(conn->hc, tv);
httpd_close_conn(conn->hc);
if (conn->linger_timer != NULL)
{
tmr_cancel(conn->linger_timer);
@ -645,7 +619,7 @@ static void linger_clear_connection(ClientData client_data, struct timeval *nowP
nvdbg("Clear connection\n");
conn = (struct connect_s *) client_data.p;
conn->linger_timer = NULL;
really_clear_connection(conn, nowP);
really_clear_connection(conn);
}
static void occasional(ClientData client_data, struct timeval *nowP)
@ -653,57 +627,6 @@ static void occasional(ClientData client_data, struct timeval *nowP)
tmr_cleanup();
}
/* Generate debugging statistics ndbg messages for all packages */
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
static void logstats(struct timeval *nowP)
{
struct timeval tv;
time_t now;
long up_secs;
long stats_secs;
if (!nowP)
{
(void)gettimeofday(&tv, NULL);
nowP = &tv;
}
now = nowP->tv_sec;
up_secs = now - start_time;
stats_secs = now - stats_time;
if (stats_secs == 0)
{
stats_secs = 1; /* fudge */
}
stats_time = now;
ndbg("up %ld seconds, stats for %ld seconds\n", up_secs, stats_secs);
thttpd_logstats(stats_secs);
httpd_memstats();
fdwatch_logstats(fw, stats_secs);
tmr_logstats(stats_secs);
}
#endif
/* Generate debugging statistics */
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
static void thttpd_logstats(long secs)
{
if (secs > 0)
{
ndbg("thttpd - %ld connections (%g/sec) %lld bytes (%g/sec)\n",
stats_connections, (float)stats_connections / secs,
(sint64) stats_bytes, (float)stats_bytes / secs);
}
stats_connections = 0;
stats_bytes = 0;
}
#endif
/****************************************************************************
* Public Functions
****************************************************************************/
@ -800,17 +723,6 @@ int thttpd_main(int argc, char **argv)
}
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
{
struct timeval ts;
gettimeofday(&ts, NULL);
start_time = ts.tv_sec;
stats_time = ts.tv_sec;
stats_connections = 0;
stats_bytes = 0;
}
#endif
/* Initialize our connections table */
connects = NEW(struct connect_s, AVAILABLE_FDS);

47
netutils/thttpd/timers.c
View File

@ -60,11 +60,6 @@
static Timer *timers[HASH_SIZE];
static Timer *free_timers;
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
static int alloc_count;
static int active_count;
static int free_count;
#endif
/****************************************************************************
* Public Data
@ -191,11 +186,6 @@ void tmr_init(void)
}
free_timers = NULL;
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
alloc_count = 0;
active_count = 0;
free_count = 0;
#endif
}
Timer *tmr_create(struct timeval *now, TimerProc *timer_proc,
@ -207,9 +197,6 @@ Timer *tmr_create(struct timeval *now, TimerProc *timer_proc,
{
tmr = free_timers;
free_timers = tmr->next;
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
--free_count;
#endif
}
else
{
@ -218,9 +205,6 @@ Timer *tmr_create(struct timeval *now, TimerProc *timer_proc,
{
return NULL;
}
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
alloc_count++;
#endif
}
tmr->timer_proc = timer_proc;
@ -249,9 +233,6 @@ Timer *tmr_create(struct timeval *now, TimerProc *timer_proc,
/* Add the new timer to the proper active list. */
l_add(tmr);
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
active_count++;
#endif
nvdbg("Return: %p\n", tmr);
return tmr;
@ -354,17 +335,11 @@ void tmr_cancel(Timer *tmr)
/* Remove it from its active list. */
l_remove(tmr);
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
active_count--;
#endif
/* And put it on the free list. */
tmr->next = free_timers;
free_timers = tmr;
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
free_count++;
#endif
tmr->prev = NULL;
}
@ -376,13 +351,7 @@ void tmr_cleanup(void)
{
tmr = free_timers;
free_timers = tmr->next;
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
free_count--;
#endif
httpd_free((void*)tmr);
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
alloc_count--;
#endif
}
}
@ -399,19 +368,3 @@ void tmr_destroy(void)
}
tmr_cleanup();
}
/* Generate debugging statistics. */
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
void tmr_logstats(long secs)
{
ndbg("timers - %d allocated, %d active, %d free",
alloc_count, active_count, free_count);
if (active_count + free_count != alloc_count)
{
ndbg("ERROR: Timer counts don't add up!");
}
}
#endif

8
netutils/thttpd/timers.h
View File

@ -132,13 +132,5 @@ extern void tmr_cleanup(void);
extern void tmr_destroy(void);
/* Generate debugging statistics syslog message. */
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
extern void tmr_logstats(long secs);
#else
# define tmr_logstats(secs)
#endif
#endif /* __NETUTILS_THTTPD_TIMERS_H */