beos.c revision 5ad238c42b1e159ee8f164515e0c4ee6c727c2fd
/* ====================================================================
* The Apache Software License, Version 1.1
*
* Copyright (c) 2000-2001 The Apache Software Foundation. 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
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Apache" and "Apache Software Foundation" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* nor may "Apache" appear in their name, without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 APACHE SOFTWARE FOUNDATION OR
* ITS 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.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
*
* Portions of this software are based upon public domain software
* originally written at the National Center for Supercomputing Applications,
* University of Illinois, Urbana-Champaign.
*/
/* The new BeOS MPM!
*
* This one basically is a single process multi threaded model, but
* I couldn't be bothered adding the spmt_ to the front of the name!
* Anyway, this is still under development so it isn't yet the default
* choice.
*/
#define CORE_PRIVATE
#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 <unistd.h>
#include <signal.h>
extern int _kset_fd_limit_(int num);
/*
* 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 apr_socket_t ** listening_sockets;
static int server_pid;
/* Keep track of the number of worker threads currently active */
static int worker_thread_count;
/* The structure used to pass unique initialization info to each thread */
typedef struct {
int slot;
} proc_info;
static void check_restart(void *data);
/*
* 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;
/* shared http_main globals... */
/* one_process */
static int one_process = 0;
#ifdef DEBUG_SIGSTOP
int raise_sigstop_flags;
#endif
/* a clean exit from a child with proper cleanup
static void clean_child_exit(int code) __attribute__ ((noreturn)); */
static void clean_child_exit(int code)
{
if (pchild)
}
/* handle all varieties of core dumping signals */
static void sig_coredump(int sig)
{
/* At this point we've got sig blocked, because we're still inside
* the signal handler. When we leave the signal handler it will
* be unblocked, and we'll take the signal... and coredump or whatever
* is appropriate for this particular Unix. In addition the parent
* will see the real signal we received -- whereas if we called
* abort() here, the parent would only see SIGABRT.
*/
}
/*****************************************************************
* 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 (shutdown_pending == 1) {
/* Um, is this _probably_ not an error, if the user has
* tried to do a shutdown twice quickly, so we won't
* worry about reporting it.
*/
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;
if (is_graceful){
}
}
{
}
{
}
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)
{
if (!one_process) {
}
/* 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)
{
/* XXX - Does this really work? - Manoj */
return is_graceful;
}
/*****************************************************************
* Child process main loop.
*/
{
long conn_id = my_child_num;
int csd;
if (csd >= FD_SETSIZE) {
"filedescriptor (%u) larger than FD_SETSIZE (%u) "
"found, you probably need to rebuild Apache with a "
return;
}
if (current_conn) {
}
}
{
int srv , n;
int curr_pollfd = 0, last_pollfd = 0;
/* each worker thread is in control of its own destiny...*/
int this_worker_should_exit = 0;
/* block the signals for this thread */
(request_rec*)NULL);
for(n=0 ; n <= num_listening_sockets ; n++)
while (1) {
/* If we're here, then chances are (unless we're the first thread created) we're going
to be held up on the accept_muetx, so doing this here shouldn't be a peformance hit.
If it is, you probably need more threads...
*/
if (this_worker_should_exit) break;
(request_rec*)NULL);
while (!this_worker_should_exit) {
if (ret != APR_SUCCESS) {
if (APR_STATUS_IS_EINTR(ret)) {
continue;
}
/* poll() will only return errors in catastrophic
* circumstances. Let's try exiting gracefully, for now. */
ap_server_conf, "apr_poll: (listen)");
} else {
/* if we've bailed in apr_poll what's the point of trying to use the data? */
if (event & APR_POLLIN){
!= APR_SUCCESS){
"error getting data from UDP!!");
}else {
/* add checking??? */
}
}
}
if (this_worker_should_exit) break;
if (num_listening_sockets == 1) {
goto got_fd;
}
else {
/* find a listener */
do {
curr_pollfd++;
if (curr_pollfd > num_listening_sockets)
curr_pollfd = 1;
/* Get the revent... */
if (event & APR_POLLIN) {
goto got_fd;
}
} while (curr_pollfd != last_pollfd);
}
}
if (!this_worker_should_exit) {
if (rv != APR_SUCCESS) {
"apr_accept");
} else {
}
}
else {
break;
}
}
return (0);
}
static int make_worker(int slot)
{
"malloc: out of memory");
}
if (one_process) {
set_signals();
return 0;
}
my_info);
if (tid < B_NO_ERROR) {
"spawn_thread: Unable to start a new thread");
/* In case system resources are maxxed 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;
}
static void check_restart(void *data)
{
if (!restart_pending && !shutdown_pending) {
"spawning a new worker thread in slot %d", slot);
}
}
/* start up a bunch of children */
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) {
&& child_slot < ap_thread_limit) {
/* we're still doing a 1-for-1 replacement of dead
* children with new children
*/
}
}
/* handled */
#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;
}
}
}
{
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;
}
return APR_ENOTIMPL;
}
{
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
*/
/* 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;
}
/* worker_thread_count_mutex
* locks the worker_thread_count so we have ana ccurate count...
*/
"Couldn't create worker thread count lock");
return 1;
}
/*
*/
if (!is_graceful) {
/* setup the scoreboard shared memory */
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... */
}
/* setup the child pool to use for the workers. Each worker creates
* a seperate pool of its own to use.
*/
/* Now that we have the child pool (pchild) we can allocate
* the listenfds and creat the pollset...
*/
listening_sockets[0] = udp_sock;
/* we assume all goes OK...hmm might want to check that! */
/* 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;
/*
* main_loop until it's all over
*/
if (!one_process) {
tell_workers_to_exit(); /* if we get here we're exiting... */
} else {
}
/* 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 locks we've created to prevent a
* potential leak of semaphores... */
return 0;
}
{
static int restart_num = 0;
if (debug)
else
{
}
/* sigh, want this only the second time around */
if (restart_num++ == 1) {
is_graceful = 0;
if (!one_process && !no_detach)
server_pid = getpid();
}
}
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 */
};