beos.c revision 43c3e6a4b559b76b750c245ee95e2782c15b4296
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* The BeOS MPM!
*
* This is a single process, with multiple worker threads.
*
* Under testing I found that given the inability of BeOS to handle threads
* and forks it didn't make sense to try and have a set of "children" threads
* that spawned the "worker" threads, so just missed out the middle mand and
* somehow arrived here.
*
* For 2.1 this has been rewritten to have simpler logic, though there is still
* some simplification that can be done. It's still a work in progress!
*
* TODO Items
*
* - on exit most worker threads segfault trying to access a kernel page.
*/
#define CORE_PRIVATE
#include <unistd.h>
#include <signal.h>
#include "apr_strings.h"
#include "apr_portable.h"
#include "httpd.h"
#include "http_main.h"
#include "http_log.h"
#include "http_config.h" /* for read_config */
#include "http_core.h" /* for get_remote_host */
#include "http_connection.h"
#include "ap_mpm.h"
#include "beosd.h"
#include "ap_listen.h"
#include "scoreboard.h"
#include "mpm_common.h"
#include "mpm.h"
#include "mpm_default.h"
#include "apr_thread_mutex.h"
#include "apr_poll.h"
extern int _kset_fd_limit_(int num);
/* Limit on the total --- clients will be locked out if more servers than
* this are needed. It is intended solely to keep the server from crashing
* when things get out of hand.
*
* We keep a hard maximum number of servers, for two reasons:
* 1) in case something goes seriously wrong, we want to stop the server starting
* threads ad infinitum and crashing the server (remember that BeOS has a 192
* thread per team limit).
* 2) it keeps the size of the scoreboard file small
* enough that we can read the whole thing without worrying too much about
* the overhead.
*/
/* we only ever have 1 main process running... */
#define HARD_SERVER_LIMIT 1
/* Limit on the threads per process. Clients will be locked out if more than
* this * HARD_SERVER_LIMIT are needed.
*
* We keep this for one reason it keeps the size of the scoreboard file small
* enough that we can read the whole thing without worrying too much about
* the overhead.
*/
#ifdef NO_THREADS
#define HARD_THREAD_LIMIT 1
#endif
#ifndef HARD_THREAD_LIMIT
#define HARD_THREAD_LIMIT 50
#endif
/*
* Actual definitions of config globals
*/
static int ap_threads_to_start=0;
static int ap_max_requests_per_thread = 0;
static int min_spare_threads=0;
static int max_spare_threads=0;
static int ap_thread_limit=0;
static int num_listening_sockets = 0;
static int mpm_state = AP_MPMQ_STARTING;
static int server_pid;
/*
* The max child slot ever assigned, preserved across restarts. Necessary
* to deal with MaxClients changes across AP_SIG_GRACEFUL restarts. We use
* this value to optimize routines that have to scan the entire scoreboard.
*/
int ap_max_child_assigned = -1;
int ap_max_threads_limit = -1;
static apr_socket_t *udp_sock;
static apr_sockaddr_t *udp_sa;
/* one_process */
static int one_process = 0;
#ifdef DEBUG_SIGSTOP
int raise_sigstop_flags;
#endif
static void check_restart(void *data);
/* When a worker thread gets to the end of it's life it dies with an
* exit value of the code supplied to this function. The thread has
* already had check_restart() registered to be called when dying, so
* we don't concern ourselves with restarting at all here. We do however
* mark the scoreboard slot as belonging to a dead server and zero out
* it's thread_id.
*
* TODO - use the status we set to determine if we need to restart the
* thread.
*/
{
(request_rec*)NULL);
}
/*****************************************************************
* Connection structures and accounting...
*/
/* volatile just in case */
static int volatile shutdown_pending;
static int volatile restart_pending;
static int volatile is_graceful;
static int volatile child_fatal;
ap_generation_t volatile ap_my_generation = 0;
/*
* ap_start_shutdown() and ap_start_restart(), below, are a first stab at
* functions to initiate shutdown or restart without relying on signals.
* Previously this was initiated in sig_term() and restart() signal handlers,
* e.g. on Win32, from the service manager. Now the service manager can
* call ap_start_shutdown() or ap_start_restart() as appropiate. Note that
* these functions can also be called by the child processes, since global
* variables are no longer used to pass on the required action to the parent.
*
* These should only be called from the parent process itself, since the
* parent process will use the shutdown_pending and restart_pending variables
* to determine whether to shutdown or restart. The child process should
* call signal_parent() directly to tell the parent to die -- this will
* cause neither of those variable to be set, which the parent will
* assume means something serious is wrong (which it will be, for the
* child to force an exit) and so do an exit anyway.
*/
static void ap_start_shutdown(void)
{
/* If the user tries to shut us down twice in quick succession then we
* may well get triggered while we are working through previous attempt
* to shutdown. We won't worry about even reporting it as it seems a little
* pointless.
*/
if (shutdown_pending == 1)
return;
shutdown_pending = 1;
}
/* do a graceful restart if graceful == 1 */
static void ap_start_restart(int graceful)
{
if (restart_pending == 1) {
/* Probably not an error - don't bother reporting it */
return;
}
restart_pending = 1;
}
/* sig_coredump attempts to handle all the potential signals we
* may get that should result in a core dump. This is called from
* the signal handler routine, so when we enter we are essentially blocked
* on the signal. Once we exit we will allow the signal to be processed by
* system, which may or may not produce a .core file. All this function does
* is try and respect the users wishes about where that file should be
* located (chdir) and then signal the parent with the signal.
*
* If we called abort() the parent would only see SIGABRT which doesn't provide
* as much information.
*/
static void sig_coredump(int sig)
{
}
{
}
{
}
/* Handle queries about our inner workings... */
{
switch(query_code){
case AP_MPMQ_MAX_DAEMON_USED:
return APR_SUCCESS;
case AP_MPMQ_IS_THREADED:
return APR_SUCCESS;
case AP_MPMQ_IS_FORKED:
return APR_SUCCESS;
return APR_SUCCESS;
return APR_SUCCESS;
case AP_MPMQ_MAX_THREADS:
return APR_SUCCESS;
*result = 0;
return APR_SUCCESS;
return APR_SUCCESS;
*result = 0;
return APR_SUCCESS;
return APR_SUCCESS;
return APR_SUCCESS;
case AP_MPMQ_MAX_DAEMONS:
return APR_SUCCESS;
case AP_MPMQ_MPM_STATE:
return APR_SUCCESS;
}
return APR_ENOTIMPL;
}
/* This accepts a connection and allows us to handle the error codes better than
* the previous code, while also making it more obvious.
*/
{
int sockdes;
if (status == APR_SUCCESS) {
return status;
}
if (APR_STATUS_IS_EINTR(status)) {
return status;
}
/* This switch statement provides us with better error details. */
switch (status) {
#ifdef ECONNABORTED
case ECONNABORTED:
#endif
#ifdef ETIMEDOUT
case ETIMEDOUT:
#endif
#ifdef EHOSTUNREACH
case EHOSTUNREACH:
#endif
#ifdef ENETUNREACH
case ENETUNREACH:
#endif
break;
#ifdef ENETDOWN
case ENETDOWN:
/*
* When the network layer has been shut down, there
* is not much use in simply exiting: the parent
* would simply re-create us (and we'd fail again).
* Use the CHILDFATAL code to tear the server down.
* @@@ Martin's idea for possible improvement:
* A different approach would be to define
* a new APEXIT_NETDOWN exit code, the reception
* of which would make the parent shutdown all
* children, then idle-loop until it detected that
* the network is up again, and restart the children.
* Ben Hyde noted that temporary ENETDOWN situations
* occur in mobile IP.
*/
"apr_socket_accept: giving up.");
return APR_EGENERAL;
#endif /*ENETDOWN*/
default:
"apr_socket_accept: (client socket)");
return APR_EGENERAL;
}
return status;
}
static void tell_workers_to_exit(void)
{
int i = 0;
for (i = 0 ; i < ap_max_child_assigned; i++){
len = 4;
break;
}
}
static void set_signals(void)
{
/* The first batch get handled by sig_coredump */
if (!one_process) {
}
/* These next two are handled by sig_term */
/* We ignore SIGPIPE */
/* we want to ignore HUPs and AP_SIG_GRACEFUL while we're busy
* processing one */
ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf, "sigaction(" AP_SIG_GRACEFUL_STRING ")");
}
/*****************************************************************
* Here follows a long bunch of generic server bookkeeping stuff...
*/
int ap_graceful_stop_signalled(void)
{
return is_graceful;
}
/* This is the thread that actually does all the work. */
{
int worker_slot = (int)dummy;
int last_poll_idx = 0;
int requests_this_child = 0;
int i;
/* each worker thread is in control of its own destiny...*/
int this_worker_should_exit = 0;
* worker. The first and longest lived is the pworker pool. From
* this we create the ptrans pool, the lifetime of which is the same
* as each connection and is reset prior to each attempt to
* process a connection.
*/
* child initializes
*/
/* block the signals for this thread only if we're not running as a
* single process.
*/
if (!one_process) {
}
/* Each worker thread is fully in control of it's destinay and so
* to allow each thread to handle the lifetime of it's own resources
* we create and use a subcontext for every thread.
* The subcontext is a child of the pconf pool.
*/
/* We add an extra socket here as we add the udp_sock we use for signalling
* death. This gets added after the others.
*/
apr_pollfd_t pfd = {0};
}
{
apr_pollfd_t pfd = {0};
}
while (!this_worker_should_exit) {
void *csd;
/* (Re)initialize this child to a pre-connection state. */
if ((ap_max_requests_per_thread > 0
/* We always (presently) have at least 2 sockets we listen on, so
* we don't have the ability for a fast path for a single socket
* as some MPM's allow :(
*/
for (;;) {
apr_int32_t numdesc = 0;
if (rv != APR_SUCCESS) {
if (APR_STATUS_IS_EINTR(rv)) {
if (one_process && shutdown_pending)
return;
continue;
}
ap_server_conf, "apr_pollset_poll: (listen)");
}
/* We can always use pdesc[0], but sockets at position N
* could end up completely starved of attention in a very
* busy server. Therefore, we round-robin across the
* returned set of descriptors. While it is possible that
* the returned set of descriptors might flip around and
* continue to starve some sockets, we happen to know the
* internal pollset implementation retains ordering
* stability of the sockets. Thus, the round-robin should
* ensure that a socket will eventually be serviced.
*/
if (last_poll_idx >= numdesc)
last_poll_idx = 0;
/* Grab a listener record from the client_data of the poll
* descriptor, and advance our saved index to round-robin
* the next fetch.
*
* ### hmm... this descriptor might have POLLERR rather
* ### than POLLIN
*/
/* The only socket we add without client_data is the first, the UDP socket
* we listen on for restart signals. If we've therefore gotten a hit on that
* listener lr will be NULL here and we know we've been told to die.
* Before we jump to the end of the while loop with this_worker_should_exit
* set to 1 (causing us to exit normally we hope) we release the accept_mutex
* as we want every thread to go through this same routine :)
* Bit of a hack, but compared to what I had before...
*/
goto got_a_black_spot;
}
goto got_fd;
}
/* Run beos_accept to accept the connection and set things up to
* allow us to process it. We always release the accept_lock here,
* even if we failt o accept as otherwise we'll starve other workers
* which would be bad.
*/
if (rv == APR_EGENERAL) {
/* resource shortage or should-not-occur occured */
} else if (rv != APR_SUCCESS)
continue;
current_conn = ap_run_create_connection(ptrans, ap_server_conf, csd, worker_slot, sbh, bucket_alloc);
if (current_conn) {
}
if (ap_my_generation !=
/* yeah, this could be non-graceful restart, in which case the
* parent will kill us soon enough, but why bother checking?
*/
}
}
}
static int make_worker(int slot)
{
if (one_process) {
set_signals();
return 0;
}
(void *)slot);
if (tid < B_NO_ERROR) {
"spawn_thread: Unable to start a new thread");
/* In case system resources are maxed out, we don't want
* Apache running away with the CPU trying to fork over and
* over and over again.
*/
(request_rec*)NULL);
sleep(10);
return -1;
}
return 0;
}
/* When a worker thread exits, this function is called. If we are not in
* a shutdown situation then we restart the worker in the slot that was
* just vacated.
*/
static void check_restart(void *data)
{
if (!restart_pending && !shutdown_pending) {
"spawning a new worker thread in slot %d", slot);
}
}
/* Start number_to_start children. This is used to start both the
* initial 'pool' of workers but also to replace existing workers who
* have reached the end of their time. It walks through the scoreboard to find
* an empty slot and starts the worker thread in that slot.
*/
static void startup_threads(int number_to_start)
{
int i;
for (i = 0; number_to_start && i < ap_thread_limit; ++i) {
continue;
if (make_worker(i) < 0)
break;
}
}
/*
* spawn_rate is the number of children that will be spawned on the
* next maintenance cycle if there aren't enough idle servers. It is
* doubled up to MAX_SPAWN_RATE, and reset only when a cycle goes by
* without the need to spawn.
*/
static int spawn_rate = 1;
#ifndef MAX_SPAWN_RATE
#define MAX_SPAWN_RATE (32)
#endif
static int hold_off_on_exponential_spawning;
static void perform_idle_server_maintenance(void)
{
int i;
int free_length;
int free_slots[MAX_SPAWN_RATE];
int last_non_dead = -1;
/* initialize the free_list */
free_length = 0;
for (i = 0; i < ap_thread_limit; ++i) {
if (free_length < spawn_rate) {
free_slots[free_length] = i;
++free_length;
}
}
else {
last_non_dead = i;
}
break;
}
}
if (free_length > 0) {
for (i = 0; i < free_length; ++i) {
make_worker(free_slots[i]);
}
/* the next time around we want to spawn twice as many if this
* wasn't good enough, but not if we've just done a graceful
*/
} else if (spawn_rate < MAX_SPAWN_RATE) {
spawn_rate *= 2;
}
} else {
spawn_rate = 1;
}
}
static void server_main_loop(int remaining_threads_to_start)
{
int child_slot;
int status;
int i;
while (!restart_pending && !shutdown_pending) {
shutdown_pending = 1;
child_fatal = 1;
return;
}
/* non-fatal death... note that it's gone in the scoreboard. */
child_slot = -1;
for (i = 0; i < ap_max_child_assigned; ++i) {
child_slot = i;
break;
}
}
if (child_slot >= 0) {
(void) ap_update_child_status_from_indexes(0, child_slot,
(request_rec*)NULL);
&& child_slot < ap_thread_limit) {
/* we're still doing a 1-for-1 replacement of dead
* children with new children
*/
}
/* TODO
#if APR_HAS_OTHER_CHILD
}
else if (apr_proc_other_child_refresh(&pid, status) == 0) {
#endif
*/
}
else if (is_graceful) {
/* Great, we've probably just lost a slot in the
* scoreboard. Somehow we don't know about this
* child.
*/
}
/* Don't perform idle maintenance when a child dies,
* only do it when there's a timeout. Remember only a
* finite number of children can die, and it's pretty
* pathological for a lot to die suddenly.
*/
continue;
}
else if (remaining_threads_to_start) {
/* we hit a 1 second timeout in which none of the previous
* generation of children needed to be reaped... so assume
* they're all done, and pick up the slack if any is left.
*/
/* In any event we really shouldn't do the code below because
* few of the servers we just started are in the IDLE state
* yet, so we'd mistakenly create an extra server.
*/
continue;
}
}
}
/* This is called to not only setup and run for the initial time, but also
* when we've asked for a restart. This means it must be able to handle both
* situations. It also means that when we exit here we should have tidied
* up after ourselves fully.
*/
{
int remaining_threads_to_start, i,j;
ap_server_conf = s;
/* Increase the available pool of fd's. This code from
* Joe Kloss <joek@be.com>
*/
"could not set FD_SETSIZE (_kset_fd_limit_ failed)");
}
/* BeOS R5 doesn't support pipes on select() calls, so we use a
* UDP socket as these are supported in both R5 and BONE. If we only cared
* about BONE we'd use a pipe, but there it is.
* As we have UDP support in APR, now use the APR functions and check all the
* return values...
*/
!= APR_SUCCESS){
"couldn't create control socket information, shutting down");
return 1;
}
_pconf) != APR_SUCCESS){
"couldn't create control socket, shutting down");
return 1;
}
"couldn't bind UDP socket!");
return 1;
}
"no listening sockets available, shutting down");
return 1;
}
/*
* Create our locks...
*/
/* accept_mutex
* used to lock around select so we only have one thread
* in select at a time
*/
if (rv != APR_SUCCESS) {
/* tsch tsch, can't have more than one thread in the accept loop
at a time so we need to fall on our sword... */
"Couldn't create accept lock");
return 1;
}
/*
*/
if (!is_graceful) {
/* setup the scoreboard shared memory */
return 1;
}
for (i = 0; i < HARD_SERVER_LIMIT; i++) {
for (j = 0;j < HARD_THREAD_LIMIT; j++)
}
}
if (HARD_SERVER_LIMIT == 1)
set_signals();
/* Sanity checks to avoid thrashing... */
if (max_spare_threads < min_spare_threads )
/* If we're doing a graceful_restart then we're going to see a lot
* of threads exiting immediately when we get into the main loop
* below (because we just sent them AP_SIG_GRACEFUL). This happens
* pretty rapidly... and for each one that exits we'll start a new one
* until we reach at least threads_min_free. But we may be permitted to
* start more than that, so we'll just keep track of how many we're
* supposed to start up without the 1 second penalty between each fork.
*/
/* sanity check on the number to start... */
}
/* If we're doing the single process thing or we're in a graceful_restart
* then we don't start threads here.
* if we're in one_process mode we don't want to start threads
* do we??
*/
if (!is_graceful && !one_process) {
} else {
/* give the system some time to recover before kicking into
* exponential mode */
}
/*
* record that we've entered the world !
*/
"%s configured -- resuming normal operations",
"Server built: %s", ap_get_server_built());
restart_pending = shutdown_pending = 0;
/* We sit in the server_main_loop() until we somehow manage to exit. When
* we do, we need to kill the workers we have, so we start by using the
* tell_workers_to_exit() function, but as it sometimes takes a short while
* to accomplish this we have a pause builtin to allow them the chance to
* gracefully exit.
*/
if (!one_process) {
snooze(1000000);
} else {
worker_thread((void*)0);
}
/* close the UDP socket we've been using... */
"removed PID file %s (pid=%ld)", pidfile,
(long)getpid());
}
if (one_process) {
return 1;
}
/*
* If we get here we're shutting down...
*/
if (shutdown_pending) {
/* Time to gracefully shut down:
* Kill child processes, tell them to call child_exit, etc...
*/
"killpg SIGTERM");
/* use ap_reclaim_child_processes starting with SIGTERM */
if (!child_fatal) { /* already recorded */
/* record the shutdown in the log */
"caught SIGTERM, shutting down");
}
return 1;
}
/* we've been told to restart */
if (is_graceful) {
AP_SIG_GRACEFUL_STRING " received. Doing graceful restart");
} else {
/* Kill 'em all. Since the child acts the same on the parents SIGTERM
* and a SIGHUP, we may as well use the same signal, because some user
* pthreads are stealing signals from us left and right.
*/
"SIGHUP received. Attempting to restart");
}
/* just before we go, tidy up the lock we created to prevent a
* potential leak of semaphores...
*/
return 0;
}
{
static int restart_num = 0;
if (debug) {
no_detach = 0;
}
else
{
}
/* sigh, want this only the second time around */
if (restart_num++ == 1) {
is_graceful = 0;
if (!one_process && !foreground) {
if (rv != APR_SUCCESS) {
"apr_proc_detach failed");
return HTTP_INTERNAL_SERVER_ERROR;
}
}
server_pid = getpid();
}
#ifdef AP_MPM_WANT_SET_MAX_MEM_FREE
#endif
return OK;
}
static void beos_hooks(apr_pool_t *p)
{
one_process = 0;
}
{
return err;
}
if (ap_threads_to_start < 0) {
"StartThreads set to a value less than 0, reset to 1");
ap_threads_to_start = 1;
}
return NULL;
}
{
return err;
}
if (min_spare_threads <= 0) {
"WARNING: detected MinSpareThreads set to non-positive.");
"Resetting to 1 to avoid almost certain Apache failure.");
"Please read the documentation.");
min_spare_threads = 1;
}
return NULL;
}
{
return err;
}
return NULL;
}
{
return err;
}
if (ap_thread_limit > HARD_THREAD_LIMIT) {
"WARNING: MaxClients of %d exceeds compile time limit "
" lowering MaxClients to %d. To increase, please "
"see the", HARD_THREAD_LIMIT);
" HARD_THREAD_LIMIT define in server/mpm/beos/mpm_default.h.");
}
else if (ap_thread_limit < 1) {
"WARNING: Require MaxClients > 0, setting to %d", HARD_THREAD_LIMIT);
}
return NULL;
}
{
return err;
}
if (ap_max_requests_per_thread < 0) {
"WARNING: MaxRequestsPerThread was set below 0"
"reset to 0, but this may not be what you want.");
}
return NULL;
}
static const command_rec beos_cmds[] = {
"Number of threads to launch at server startup"),
"Minimum number of idle children, to handle request spikes"),
"Maximum number of idle children" ),
"Maximum number of children alive at the same time (max threads)" ),
"Maximum number of requests served by a thread" ),
{ NULL }
};
NULL, /* hook to run before apache parses args */
NULL, /* create per-directory config structure */
NULL, /* merge per-directory config structures */
NULL, /* create per-server config structure */
NULL, /* merge per-server config structures */
beos_cmds, /* command apr_table_t */
beos_hooks /* register_hooks */
};