b935dc85c3
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.
100 lines
2.9 KiB
C
100 lines
2.9 KiB
C
/* tinyproxy - A fast light-weight HTTP proxy
|
|
* Copyright (C) 2002 Robert James Kaes <rjkaes@users.sourceforge.net>
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
/* Debugging versions of various heap related functions are combined
|
|
* here. The debugging versions include assertions and also print
|
|
* (to standard error) the function called along with the amount
|
|
* of memory allocated, and where the memory is pointing. The
|
|
* format of the log message is standardized.
|
|
*/
|
|
|
|
#include "main.h"
|
|
#include "heap.h"
|
|
#include "text.h"
|
|
|
|
#ifndef NDEBUG
|
|
|
|
void *debugging_calloc (size_t nmemb, size_t size, const char *file,
|
|
unsigned long line)
|
|
{
|
|
void *ptr;
|
|
|
|
assert (nmemb > 0);
|
|
assert (size > 0);
|
|
|
|
ptr = calloc (nmemb, size);
|
|
fprintf (stderr, "{calloc: %p:%lu x %lu} %s:%lu\n", ptr,
|
|
(unsigned long) nmemb, (unsigned long) size, file, line);
|
|
return ptr;
|
|
}
|
|
|
|
void *debugging_malloc (size_t size, const char *file, unsigned long line)
|
|
{
|
|
void *ptr;
|
|
|
|
assert (size > 0);
|
|
|
|
ptr = malloc (size);
|
|
fprintf (stderr, "{malloc: %p:%lu} %s:%lu\n", ptr,
|
|
(unsigned long) size, file, line);
|
|
return ptr;
|
|
}
|
|
|
|
void *debugging_realloc (void *ptr, size_t size, const char *file,
|
|
unsigned long line)
|
|
{
|
|
void *newptr;
|
|
|
|
assert (size > 0);
|
|
|
|
newptr = realloc (ptr, size);
|
|
fprintf (stderr, "{realloc: %p -> %p:%lu} %s:%lu\n", ptr, newptr,
|
|
(unsigned long) size, file, line);
|
|
return newptr;
|
|
}
|
|
|
|
void debugging_free (void *ptr, const char *file, unsigned long line)
|
|
{
|
|
fprintf (stderr, "{free: %p} %s:%lu\n", ptr, file, line);
|
|
|
|
if (ptr != NULL)
|
|
free (ptr);
|
|
return;
|
|
}
|
|
|
|
char *debugging_strdup (const char *s, const char *file, unsigned long line)
|
|
{
|
|
char *ptr;
|
|
size_t len;
|
|
|
|
assert (s != NULL);
|
|
|
|
len = strlen (s) + 1;
|
|
ptr = (char *) malloc (len);
|
|
if (!ptr)
|
|
return NULL;
|
|
memcpy (ptr, s, len);
|
|
|
|
fprintf (stderr, "{strdup: %p:%lu} %s:%lu\n", ptr,
|
|
(unsigned long) len, file, line);
|
|
return ptr;
|
|
}
|
|
|
|
#endif /* !NDEBUG */
|
|
|