2008-05-24 01:05:49 -07:00
|
|
|
/* tinyproxy - A fast light-weight HTTP proxy
|
|
|
|
|
* Copyright (C) 2000 Robert James Kaes <rjkaes@users.sourceforge.net>
|
2000-09-11 17:06:09 -07:00
|
|
|
*
|
2008-05-24 01:05:49 -07:00
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
|
* (at your option) any later version.
|
|
|
|
|
*
|
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU General Public License along
|
|
|
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/* This module handles the statistics for tinyproxy. There are only two
|
2000-09-11 17:06:09 -07:00
|
|
|
* public API functions. The reason for the functions, rather than just a
|
|
|
|
|
* external structure is that tinyproxy is now multi-threaded and we can
|
2002-05-26 11:53:14 -07:00
|
|
|
* not allow more than one child to access the statistics at the same
|
2000-09-11 17:06:09 -07:00
|
|
|
* time. This is prevented by a mutex. If there is a need for more
|
|
|
|
|
* statistics in the future, just add to the structure, enum (in the header),
|
|
|
|
|
* and the switch statement in update_stats().
|
|
|
|
|
*/
|
|
|
|
|
|
2009-08-06 15:12:53 -07:00
|
|
|
#include "main.h"
|
2000-09-11 17:06:09 -07:00
|
|
|
|
|
|
|
|
#include "log.h"
|
2002-05-23 11:20:27 -07:00
|
|
|
#include "heap.h"
|
2008-05-24 01:17:14 -07:00
|
|
|
#include "html-error.h"
|
2000-09-11 17:06:09 -07:00
|
|
|
#include "stats.h"
|
2001-09-08 11:58:37 -07:00
|
|
|
#include "utils.h"
|
2009-12-07 13:23:31 -08:00
|
|
|
#include "conf.h"
|
simplify codebase by using one thread/conn, instead of preforked procs
the existing codebase used an elaborate and complex approach for
its parallelism:
5 different config file options, namely
- MaxClients
- MinSpareServers
- MaxSpareServers
- StartServers
- MaxRequestsPerChild
were used to steer how (and how many) parallel processes tinyproxy
would spin up at start, how many processes at each point needed to
be idle, etc.
it seems all preforked processes would listen on the server port
and compete with each other about who would get assigned the new
incoming connections.
since some data needs to be shared across those processes, a half-
baked "shared memory" implementation was provided for this purpose.
that implementation used to use files in the filesystem, and since
it had a big FIXME comment, the author was well aware of how hackish
that approach was.
this entire complexity is now removed. the main thread enters
a loop which polls on the listening fds, then spins up a new
thread per connection, until the maximum number of connections
(MaxClients) is hit. this is the only of the 5 config options
left after this cleanup. since threads share the same address space,
the code necessary for shared memory access has been removed.
this means that the other 4 mentioned config option will now
produce a parse error, when encountered.
currently each thread uses a hardcoded default of 256KB per thread
for the thread stack size, which is quite lavish and should be
sufficient for even the worst C libraries, but people may want
to tweak this value to the bare minimum, thus we may provide a new
config option for this purpose in the future.
i suspect that on heavily optimized C libraries such a musl, a
stack size of 8-16 KB per thread could be sufficient.
since the existing list implementation in vector.c did not provide
a way to remove a single item from an existing list, i added my
own list implementation from my libulz library which offers this
functionality, rather than trying to add an ad-hoc, and perhaps
buggy implementation to the vector_t list code. the sblist
code is contained in an 80 line C file and as simple as it can get,
while offering good performance and is proven bugfree due to years
of use in other projects.
2018-12-16 16:23:09 -08:00
|
|
|
#include <pthread.h>
|
2000-09-11 17:06:09 -07:00
|
|
|
|
2009-09-14 12:41:25 -07:00
|
|
|
struct stat_s {
|
|
|
|
|
unsigned long int num_reqs;
|
|
|
|
|
unsigned long int num_badcons;
|
|
|
|
|
unsigned long int num_open;
|
|
|
|
|
unsigned long int num_refused;
|
|
|
|
|
unsigned long int num_denied;
|
2000-09-11 17:06:09 -07:00
|
|
|
};
|
|
|
|
|
|
2020-09-15 15:28:33 -07:00
|
|
|
static struct stat_s stats_buf, *stats;
|
simplify codebase by using one thread/conn, instead of preforked procs
the existing codebase used an elaborate and complex approach for
its parallelism:
5 different config file options, namely
- MaxClients
- MinSpareServers
- MaxSpareServers
- StartServers
- MaxRequestsPerChild
were used to steer how (and how many) parallel processes tinyproxy
would spin up at start, how many processes at each point needed to
be idle, etc.
it seems all preforked processes would listen on the server port
and compete with each other about who would get assigned the new
incoming connections.
since some data needs to be shared across those processes, a half-
baked "shared memory" implementation was provided for this purpose.
that implementation used to use files in the filesystem, and since
it had a big FIXME comment, the author was well aware of how hackish
that approach was.
this entire complexity is now removed. the main thread enters
a loop which polls on the listening fds, then spins up a new
thread per connection, until the maximum number of connections
(MaxClients) is hit. this is the only of the 5 config options
left after this cleanup. since threads share the same address space,
the code necessary for shared memory access has been removed.
this means that the other 4 mentioned config option will now
produce a parse error, when encountered.
currently each thread uses a hardcoded default of 256KB per thread
for the thread stack size, which is quite lavish and should be
sufficient for even the worst C libraries, but people may want
to tweak this value to the bare minimum, thus we may provide a new
config option for this purpose in the future.
i suspect that on heavily optimized C libraries such a musl, a
stack size of 8-16 KB per thread could be sufficient.
since the existing list implementation in vector.c did not provide
a way to remove a single item from an existing list, i added my
own list implementation from my libulz library which offers this
functionality, rather than trying to add an ad-hoc, and perhaps
buggy implementation to the vector_t list code. the sblist
code is contained in an 80 line C file and as simple as it can get,
while offering good performance and is proven bugfree due to years
of use in other projects.
2018-12-16 16:23:09 -08:00
|
|
|
static pthread_mutex_t stats_update_lock = PTHREAD_MUTEX_INITIALIZER;
|
|
|
|
|
static pthread_mutex_t stats_file_lock = PTHREAD_MUTEX_INITIALIZER;
|
2000-09-11 17:06:09 -07:00
|
|
|
|
|
|
|
|
/*
|
2002-05-23 21:45:32 -07:00
|
|
|
* Initialize the statistics information to zero.
|
2000-09-11 17:06:09 -07:00
|
|
|
*/
|
2009-09-14 12:41:25 -07:00
|
|
|
void init_stats (void)
|
2000-09-11 17:06:09 -07:00
|
|
|
{
|
2020-09-15 15:28:33 -07:00
|
|
|
stats = &stats_buf;
|
2000-09-11 17:06:09 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Display the statics of the tinyproxy server.
|
|
|
|
|
*/
|
2009-09-20 21:34:09 -07:00
|
|
|
int
|
|
|
|
|
showstats (struct conn_s *connptr)
|
2000-09-11 17:06:09 -07:00
|
|
|
{
|
2009-09-14 12:41:25 -07:00
|
|
|
char *message_buffer;
|
|
|
|
|
char opens[16], reqs[16], badconns[16], denied[16], refused[16];
|
|
|
|
|
FILE *statfile;
|
|
|
|
|
|
|
|
|
|
snprintf (opens, sizeof (opens), "%lu", stats->num_open);
|
|
|
|
|
snprintf (reqs, sizeof (reqs), "%lu", stats->num_reqs);
|
|
|
|
|
snprintf (badconns, sizeof (badconns), "%lu", stats->num_badcons);
|
|
|
|
|
snprintf (denied, sizeof (denied), "%lu", stats->num_denied);
|
|
|
|
|
snprintf (refused, sizeof (refused), "%lu", stats->num_refused);
|
|
|
|
|
|
simplify codebase by using one thread/conn, instead of preforked procs
the existing codebase used an elaborate and complex approach for
its parallelism:
5 different config file options, namely
- MaxClients
- MinSpareServers
- MaxSpareServers
- StartServers
- MaxRequestsPerChild
were used to steer how (and how many) parallel processes tinyproxy
would spin up at start, how many processes at each point needed to
be idle, etc.
it seems all preforked processes would listen on the server port
and compete with each other about who would get assigned the new
incoming connections.
since some data needs to be shared across those processes, a half-
baked "shared memory" implementation was provided for this purpose.
that implementation used to use files in the filesystem, and since
it had a big FIXME comment, the author was well aware of how hackish
that approach was.
this entire complexity is now removed. the main thread enters
a loop which polls on the listening fds, then spins up a new
thread per connection, until the maximum number of connections
(MaxClients) is hit. this is the only of the 5 config options
left after this cleanup. since threads share the same address space,
the code necessary for shared memory access has been removed.
this means that the other 4 mentioned config option will now
produce a parse error, when encountered.
currently each thread uses a hardcoded default of 256KB per thread
for the thread stack size, which is quite lavish and should be
sufficient for even the worst C libraries, but people may want
to tweak this value to the bare minimum, thus we may provide a new
config option for this purpose in the future.
i suspect that on heavily optimized C libraries such a musl, a
stack size of 8-16 KB per thread could be sufficient.
since the existing list implementation in vector.c did not provide
a way to remove a single item from an existing list, i added my
own list implementation from my libulz library which offers this
functionality, rather than trying to add an ad-hoc, and perhaps
buggy implementation to the vector_t list code. the sblist
code is contained in an 80 line C file and as simple as it can get,
while offering good performance and is proven bugfree due to years
of use in other projects.
2018-12-16 16:23:09 -08:00
|
|
|
pthread_mutex_lock(&stats_file_lock);
|
|
|
|
|
|
2020-01-15 08:09:41 -08:00
|
|
|
if (!config->statpage || (!(statfile = fopen (config->statpage, "r")))) {
|
2009-09-14 12:41:25 -07:00
|
|
|
message_buffer = (char *) safemalloc (MAXBUFFSIZE);
|
simplify codebase by using one thread/conn, instead of preforked procs
the existing codebase used an elaborate and complex approach for
its parallelism:
5 different config file options, namely
- MaxClients
- MinSpareServers
- MaxSpareServers
- StartServers
- MaxRequestsPerChild
were used to steer how (and how many) parallel processes tinyproxy
would spin up at start, how many processes at each point needed to
be idle, etc.
it seems all preforked processes would listen on the server port
and compete with each other about who would get assigned the new
incoming connections.
since some data needs to be shared across those processes, a half-
baked "shared memory" implementation was provided for this purpose.
that implementation used to use files in the filesystem, and since
it had a big FIXME comment, the author was well aware of how hackish
that approach was.
this entire complexity is now removed. the main thread enters
a loop which polls on the listening fds, then spins up a new
thread per connection, until the maximum number of connections
(MaxClients) is hit. this is the only of the 5 config options
left after this cleanup. since threads share the same address space,
the code necessary for shared memory access has been removed.
this means that the other 4 mentioned config option will now
produce a parse error, when encountered.
currently each thread uses a hardcoded default of 256KB per thread
for the thread stack size, which is quite lavish and should be
sufficient for even the worst C libraries, but people may want
to tweak this value to the bare minimum, thus we may provide a new
config option for this purpose in the future.
i suspect that on heavily optimized C libraries such a musl, a
stack size of 8-16 KB per thread could be sufficient.
since the existing list implementation in vector.c did not provide
a way to remove a single item from an existing list, i added my
own list implementation from my libulz library which offers this
functionality, rather than trying to add an ad-hoc, and perhaps
buggy implementation to the vector_t list code. the sblist
code is contained in an 80 line C file and as simple as it can get,
while offering good performance and is proven bugfree due to years
of use in other projects.
2018-12-16 16:23:09 -08:00
|
|
|
if (!message_buffer) {
|
|
|
|
|
err_minus_one:
|
|
|
|
|
pthread_mutex_unlock(&stats_file_lock);
|
2009-09-14 12:41:25 -07:00
|
|
|
return -1;
|
simplify codebase by using one thread/conn, instead of preforked procs
the existing codebase used an elaborate and complex approach for
its parallelism:
5 different config file options, namely
- MaxClients
- MinSpareServers
- MaxSpareServers
- StartServers
- MaxRequestsPerChild
were used to steer how (and how many) parallel processes tinyproxy
would spin up at start, how many processes at each point needed to
be idle, etc.
it seems all preforked processes would listen on the server port
and compete with each other about who would get assigned the new
incoming connections.
since some data needs to be shared across those processes, a half-
baked "shared memory" implementation was provided for this purpose.
that implementation used to use files in the filesystem, and since
it had a big FIXME comment, the author was well aware of how hackish
that approach was.
this entire complexity is now removed. the main thread enters
a loop which polls on the listening fds, then spins up a new
thread per connection, until the maximum number of connections
(MaxClients) is hit. this is the only of the 5 config options
left after this cleanup. since threads share the same address space,
the code necessary for shared memory access has been removed.
this means that the other 4 mentioned config option will now
produce a parse error, when encountered.
currently each thread uses a hardcoded default of 256KB per thread
for the thread stack size, which is quite lavish and should be
sufficient for even the worst C libraries, but people may want
to tweak this value to the bare minimum, thus we may provide a new
config option for this purpose in the future.
i suspect that on heavily optimized C libraries such a musl, a
stack size of 8-16 KB per thread could be sufficient.
since the existing list implementation in vector.c did not provide
a way to remove a single item from an existing list, i added my
own list implementation from my libulz library which offers this
functionality, rather than trying to add an ad-hoc, and perhaps
buggy implementation to the vector_t list code. the sblist
code is contained in an 80 line C file and as simple as it can get,
while offering good performance and is proven bugfree due to years
of use in other projects.
2018-12-16 16:23:09 -08:00
|
|
|
}
|
2009-09-14 12:41:25 -07:00
|
|
|
|
2009-09-20 21:34:09 -07:00
|
|
|
snprintf
|
|
|
|
|
(message_buffer, MAXBUFFSIZE,
|
|
|
|
|
"<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n"
|
|
|
|
|
"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.1//EN\" "
|
|
|
|
|
"\"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd\">\n"
|
|
|
|
|
"<html>\n"
|
|
|
|
|
"<head><title>%s version %s run-time statistics</title></head>\n"
|
|
|
|
|
"<body>\n"
|
|
|
|
|
"<h1>%s version %s run-time statistics</h1>\n"
|
|
|
|
|
"<p>\n"
|
|
|
|
|
"Number of open connections: %lu<br />\n"
|
|
|
|
|
"Number of requests: %lu<br />\n"
|
|
|
|
|
"Number of bad connections: %lu<br />\n"
|
|
|
|
|
"Number of denied connections: %lu<br />\n"
|
|
|
|
|
"Number of refused connections due to high load: %lu\n"
|
|
|
|
|
"</p>\n"
|
|
|
|
|
"<hr />\n"
|
|
|
|
|
"<p><em>Generated by %s version %s.</em></p>\n" "</body>\n"
|
|
|
|
|
"</html>\n",
|
|
|
|
|
PACKAGE, VERSION, PACKAGE, VERSION,
|
|
|
|
|
stats->num_open,
|
|
|
|
|
stats->num_reqs,
|
|
|
|
|
stats->num_badcons, stats->num_denied,
|
|
|
|
|
stats->num_refused, PACKAGE, VERSION);
|
2009-09-14 12:41:25 -07:00
|
|
|
|
2009-09-20 21:34:09 -07:00
|
|
|
if (send_http_message (connptr, 200, "OK",
|
|
|
|
|
message_buffer) < 0) {
|
2009-09-14 12:41:25 -07:00
|
|
|
safefree (message_buffer);
|
simplify codebase by using one thread/conn, instead of preforked procs
the existing codebase used an elaborate and complex approach for
its parallelism:
5 different config file options, namely
- MaxClients
- MinSpareServers
- MaxSpareServers
- StartServers
- MaxRequestsPerChild
were used to steer how (and how many) parallel processes tinyproxy
would spin up at start, how many processes at each point needed to
be idle, etc.
it seems all preforked processes would listen on the server port
and compete with each other about who would get assigned the new
incoming connections.
since some data needs to be shared across those processes, a half-
baked "shared memory" implementation was provided for this purpose.
that implementation used to use files in the filesystem, and since
it had a big FIXME comment, the author was well aware of how hackish
that approach was.
this entire complexity is now removed. the main thread enters
a loop which polls on the listening fds, then spins up a new
thread per connection, until the maximum number of connections
(MaxClients) is hit. this is the only of the 5 config options
left after this cleanup. since threads share the same address space,
the code necessary for shared memory access has been removed.
this means that the other 4 mentioned config option will now
produce a parse error, when encountered.
currently each thread uses a hardcoded default of 256KB per thread
for the thread stack size, which is quite lavish and should be
sufficient for even the worst C libraries, but people may want
to tweak this value to the bare minimum, thus we may provide a new
config option for this purpose in the future.
i suspect that on heavily optimized C libraries such a musl, a
stack size of 8-16 KB per thread could be sufficient.
since the existing list implementation in vector.c did not provide
a way to remove a single item from an existing list, i added my
own list implementation from my libulz library which offers this
functionality, rather than trying to add an ad-hoc, and perhaps
buggy implementation to the vector_t list code. the sblist
code is contained in an 80 line C file and as simple as it can get,
while offering good performance and is proven bugfree due to years
of use in other projects.
2018-12-16 16:23:09 -08:00
|
|
|
goto err_minus_one;
|
2009-09-14 12:41:25 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
safefree (message_buffer);
|
simplify codebase by using one thread/conn, instead of preforked procs
the existing codebase used an elaborate and complex approach for
its parallelism:
5 different config file options, namely
- MaxClients
- MinSpareServers
- MaxSpareServers
- StartServers
- MaxRequestsPerChild
were used to steer how (and how many) parallel processes tinyproxy
would spin up at start, how many processes at each point needed to
be idle, etc.
it seems all preforked processes would listen on the server port
and compete with each other about who would get assigned the new
incoming connections.
since some data needs to be shared across those processes, a half-
baked "shared memory" implementation was provided for this purpose.
that implementation used to use files in the filesystem, and since
it had a big FIXME comment, the author was well aware of how hackish
that approach was.
this entire complexity is now removed. the main thread enters
a loop which polls on the listening fds, then spins up a new
thread per connection, until the maximum number of connections
(MaxClients) is hit. this is the only of the 5 config options
left after this cleanup. since threads share the same address space,
the code necessary for shared memory access has been removed.
this means that the other 4 mentioned config option will now
produce a parse error, when encountered.
currently each thread uses a hardcoded default of 256KB per thread
for the thread stack size, which is quite lavish and should be
sufficient for even the worst C libraries, but people may want
to tweak this value to the bare minimum, thus we may provide a new
config option for this purpose in the future.
i suspect that on heavily optimized C libraries such a musl, a
stack size of 8-16 KB per thread could be sufficient.
since the existing list implementation in vector.c did not provide
a way to remove a single item from an existing list, i added my
own list implementation from my libulz library which offers this
functionality, rather than trying to add an ad-hoc, and perhaps
buggy implementation to the vector_t list code. the sblist
code is contained in an 80 line C file and as simple as it can get,
while offering good performance and is proven bugfree due to years
of use in other projects.
2018-12-16 16:23:09 -08:00
|
|
|
pthread_mutex_unlock(&stats_file_lock);
|
2009-09-14 12:41:25 -07:00
|
|
|
return 0;
|
2008-12-08 05:39:44 -08:00
|
|
|
}
|
2009-09-14 12:41:25 -07:00
|
|
|
add_error_variable (connptr, "opens", opens);
|
|
|
|
|
add_error_variable (connptr, "reqs", reqs);
|
|
|
|
|
add_error_variable (connptr, "badconns", badconns);
|
|
|
|
|
add_error_variable (connptr, "deniedconns", denied);
|
|
|
|
|
add_error_variable (connptr, "refusedconns", refused);
|
|
|
|
|
add_standard_vars (connptr);
|
2021-03-28 12:22:32 -07:00
|
|
|
send_http_headers (connptr, 200, "Statistic requested", "");
|
2009-09-14 12:41:25 -07:00
|
|
|
send_html_file (statfile, connptr);
|
|
|
|
|
fclose (statfile);
|
simplify codebase by using one thread/conn, instead of preforked procs
the existing codebase used an elaborate and complex approach for
its parallelism:
5 different config file options, namely
- MaxClients
- MinSpareServers
- MaxSpareServers
- StartServers
- MaxRequestsPerChild
were used to steer how (and how many) parallel processes tinyproxy
would spin up at start, how many processes at each point needed to
be idle, etc.
it seems all preforked processes would listen on the server port
and compete with each other about who would get assigned the new
incoming connections.
since some data needs to be shared across those processes, a half-
baked "shared memory" implementation was provided for this purpose.
that implementation used to use files in the filesystem, and since
it had a big FIXME comment, the author was well aware of how hackish
that approach was.
this entire complexity is now removed. the main thread enters
a loop which polls on the listening fds, then spins up a new
thread per connection, until the maximum number of connections
(MaxClients) is hit. this is the only of the 5 config options
left after this cleanup. since threads share the same address space,
the code necessary for shared memory access has been removed.
this means that the other 4 mentioned config option will now
produce a parse error, when encountered.
currently each thread uses a hardcoded default of 256KB per thread
for the thread stack size, which is quite lavish and should be
sufficient for even the worst C libraries, but people may want
to tweak this value to the bare minimum, thus we may provide a new
config option for this purpose in the future.
i suspect that on heavily optimized C libraries such a musl, a
stack size of 8-16 KB per thread could be sufficient.
since the existing list implementation in vector.c did not provide
a way to remove a single item from an existing list, i added my
own list implementation from my libulz library which offers this
functionality, rather than trying to add an ad-hoc, and perhaps
buggy implementation to the vector_t list code. the sblist
code is contained in an 80 line C file and as simple as it can get,
while offering good performance and is proven bugfree due to years
of use in other projects.
2018-12-16 16:23:09 -08:00
|
|
|
pthread_mutex_unlock(&stats_file_lock);
|
2009-09-14 12:41:25 -07:00
|
|
|
|
|
|
|
|
return 0;
|
2000-09-11 17:06:09 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Update the value of the statistics. The update_level is defined in
|
|
|
|
|
* stats.h
|
|
|
|
|
*/
|
2009-09-14 12:41:25 -07:00
|
|
|
int update_stats (status_t update_level)
|
2000-09-11 17:06:09 -07:00
|
|
|
{
|
simplify codebase by using one thread/conn, instead of preforked procs
the existing codebase used an elaborate and complex approach for
its parallelism:
5 different config file options, namely
- MaxClients
- MinSpareServers
- MaxSpareServers
- StartServers
- MaxRequestsPerChild
were used to steer how (and how many) parallel processes tinyproxy
would spin up at start, how many processes at each point needed to
be idle, etc.
it seems all preforked processes would listen on the server port
and compete with each other about who would get assigned the new
incoming connections.
since some data needs to be shared across those processes, a half-
baked "shared memory" implementation was provided for this purpose.
that implementation used to use files in the filesystem, and since
it had a big FIXME comment, the author was well aware of how hackish
that approach was.
this entire complexity is now removed. the main thread enters
a loop which polls on the listening fds, then spins up a new
thread per connection, until the maximum number of connections
(MaxClients) is hit. this is the only of the 5 config options
left after this cleanup. since threads share the same address space,
the code necessary for shared memory access has been removed.
this means that the other 4 mentioned config option will now
produce a parse error, when encountered.
currently each thread uses a hardcoded default of 256KB per thread
for the thread stack size, which is quite lavish and should be
sufficient for even the worst C libraries, but people may want
to tweak this value to the bare minimum, thus we may provide a new
config option for this purpose in the future.
i suspect that on heavily optimized C libraries such a musl, a
stack size of 8-16 KB per thread could be sufficient.
since the existing list implementation in vector.c did not provide
a way to remove a single item from an existing list, i added my
own list implementation from my libulz library which offers this
functionality, rather than trying to add an ad-hoc, and perhaps
buggy implementation to the vector_t list code. the sblist
code is contained in an 80 line C file and as simple as it can get,
while offering good performance and is proven bugfree due to years
of use in other projects.
2018-12-16 16:23:09 -08:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
|
|
pthread_mutex_lock(&stats_update_lock);
|
2009-09-14 12:41:25 -07:00
|
|
|
switch (update_level) {
|
|
|
|
|
case STAT_BADCONN:
|
|
|
|
|
++stats->num_badcons;
|
|
|
|
|
break;
|
|
|
|
|
case STAT_OPEN:
|
|
|
|
|
++stats->num_open;
|
|
|
|
|
++stats->num_reqs;
|
|
|
|
|
break;
|
|
|
|
|
case STAT_CLOSE:
|
|
|
|
|
--stats->num_open;
|
|
|
|
|
break;
|
|
|
|
|
case STAT_REFUSE:
|
|
|
|
|
++stats->num_refused;
|
|
|
|
|
break;
|
|
|
|
|
case STAT_DENIED:
|
|
|
|
|
++stats->num_denied;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
simplify codebase by using one thread/conn, instead of preforked procs
the existing codebase used an elaborate and complex approach for
its parallelism:
5 different config file options, namely
- MaxClients
- MinSpareServers
- MaxSpareServers
- StartServers
- MaxRequestsPerChild
were used to steer how (and how many) parallel processes tinyproxy
would spin up at start, how many processes at each point needed to
be idle, etc.
it seems all preforked processes would listen on the server port
and compete with each other about who would get assigned the new
incoming connections.
since some data needs to be shared across those processes, a half-
baked "shared memory" implementation was provided for this purpose.
that implementation used to use files in the filesystem, and since
it had a big FIXME comment, the author was well aware of how hackish
that approach was.
this entire complexity is now removed. the main thread enters
a loop which polls on the listening fds, then spins up a new
thread per connection, until the maximum number of connections
(MaxClients) is hit. this is the only of the 5 config options
left after this cleanup. since threads share the same address space,
the code necessary for shared memory access has been removed.
this means that the other 4 mentioned config option will now
produce a parse error, when encountered.
currently each thread uses a hardcoded default of 256KB per thread
for the thread stack size, which is quite lavish and should be
sufficient for even the worst C libraries, but people may want
to tweak this value to the bare minimum, thus we may provide a new
config option for this purpose in the future.
i suspect that on heavily optimized C libraries such a musl, a
stack size of 8-16 KB per thread could be sufficient.
since the existing list implementation in vector.c did not provide
a way to remove a single item from an existing list, i added my
own list implementation from my libulz library which offers this
functionality, rather than trying to add an ad-hoc, and perhaps
buggy implementation to the vector_t list code. the sblist
code is contained in an 80 line C file and as simple as it can get,
while offering good performance and is proven bugfree due to years
of use in other projects.
2018-12-16 16:23:09 -08:00
|
|
|
ret = -1;
|
2009-09-14 12:41:25 -07:00
|
|
|
}
|
simplify codebase by using one thread/conn, instead of preforked procs
the existing codebase used an elaborate and complex approach for
its parallelism:
5 different config file options, namely
- MaxClients
- MinSpareServers
- MaxSpareServers
- StartServers
- MaxRequestsPerChild
were used to steer how (and how many) parallel processes tinyproxy
would spin up at start, how many processes at each point needed to
be idle, etc.
it seems all preforked processes would listen on the server port
and compete with each other about who would get assigned the new
incoming connections.
since some data needs to be shared across those processes, a half-
baked "shared memory" implementation was provided for this purpose.
that implementation used to use files in the filesystem, and since
it had a big FIXME comment, the author was well aware of how hackish
that approach was.
this entire complexity is now removed. the main thread enters
a loop which polls on the listening fds, then spins up a new
thread per connection, until the maximum number of connections
(MaxClients) is hit. this is the only of the 5 config options
left after this cleanup. since threads share the same address space,
the code necessary for shared memory access has been removed.
this means that the other 4 mentioned config option will now
produce a parse error, when encountered.
currently each thread uses a hardcoded default of 256KB per thread
for the thread stack size, which is quite lavish and should be
sufficient for even the worst C libraries, but people may want
to tweak this value to the bare minimum, thus we may provide a new
config option for this purpose in the future.
i suspect that on heavily optimized C libraries such a musl, a
stack size of 8-16 KB per thread could be sufficient.
since the existing list implementation in vector.c did not provide
a way to remove a single item from an existing list, i added my
own list implementation from my libulz library which offers this
functionality, rather than trying to add an ad-hoc, and perhaps
buggy implementation to the vector_t list code. the sblist
code is contained in an 80 line C file and as simple as it can get,
while offering good performance and is proven bugfree due to years
of use in other projects.
2018-12-16 16:23:09 -08:00
|
|
|
pthread_mutex_unlock(&stats_update_lock);
|
2009-09-14 12:41:25 -07:00
|
|
|
|
simplify codebase by using one thread/conn, instead of preforked procs
the existing codebase used an elaborate and complex approach for
its parallelism:
5 different config file options, namely
- MaxClients
- MinSpareServers
- MaxSpareServers
- StartServers
- MaxRequestsPerChild
were used to steer how (and how many) parallel processes tinyproxy
would spin up at start, how many processes at each point needed to
be idle, etc.
it seems all preforked processes would listen on the server port
and compete with each other about who would get assigned the new
incoming connections.
since some data needs to be shared across those processes, a half-
baked "shared memory" implementation was provided for this purpose.
that implementation used to use files in the filesystem, and since
it had a big FIXME comment, the author was well aware of how hackish
that approach was.
this entire complexity is now removed. the main thread enters
a loop which polls on the listening fds, then spins up a new
thread per connection, until the maximum number of connections
(MaxClients) is hit. this is the only of the 5 config options
left after this cleanup. since threads share the same address space,
the code necessary for shared memory access has been removed.
this means that the other 4 mentioned config option will now
produce a parse error, when encountered.
currently each thread uses a hardcoded default of 256KB per thread
for the thread stack size, which is quite lavish and should be
sufficient for even the worst C libraries, but people may want
to tweak this value to the bare minimum, thus we may provide a new
config option for this purpose in the future.
i suspect that on heavily optimized C libraries such a musl, a
stack size of 8-16 KB per thread could be sufficient.
since the existing list implementation in vector.c did not provide
a way to remove a single item from an existing list, i added my
own list implementation from my libulz library which offers this
functionality, rather than trying to add an ad-hoc, and perhaps
buggy implementation to the vector_t list code. the sblist
code is contained in an 80 line C file and as simple as it can get,
while offering good performance and is proven bugfree due to years
of use in other projects.
2018-12-16 16:23:09 -08:00
|
|
|
return ret;
|
2000-09-11 17:06:09 -07:00
|
|
|
}
|
