dexter.c revision b6055b7832a0e4d0818416252fff5925aaebae4b
/* ====================================================================
* The Apache Software License, Version 1.1
*
* Copyright (c) 2000 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.
*/
#define CORE_PRIVATE
#include "ap_config.h"
#include "apr_portable.h"
#include "apr_strings.h"
#include "apr_file_io.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 "unixd.h"
#include "mpm_common.h"
#include "iol_socket.h"
#include "ap_listen.h"
#include "mpm_default.h"
#include "mpm.h"
#include "scoreboard.h"
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <poll.h>
#ifdef HAVE_SYS_SOCKET_H
#endif
#ifdef HAVE_NETINET_TCP_H
#endif
#include <pthread.h>
#include <signal.h>
/*
* Actual definitions of config globals
*/
static int threads_to_start = 0; /* Worker threads per child */
static int min_spare_threads = 0;
static int max_spare_threads = 0;
static int max_threads = 0;
static int max_requests_per_child = 0;
static const char *ap_pid_fname=NULL;
static int num_daemons=0;
static int workers_may_exit = 0;
static int requests_this_child;
static int num_listenfds = 0;
static ap_socket_t **listenfds;
/*
* The max child slot ever assigned, preserved across restarts. Necessary
* to deal with NumServers changes across SIGWINCH restarts. We use this
* value to optimize routines that have to scan the entire child table.
*
* XXX - It might not be worth keeping this code in. There aren't very
* many child processes in this MPM.
*/
int ap_max_daemons_limit = -1;
char ap_coredump_dir[MAX_STRING_LEN];
static pthread_mutex_t pipe_of_death_mutex;
/* *Non*-shared http_main globals... */
/* one_process --- debugging mode variable; can be set from the command line
* with the -X flag. If set, this gets you the child_main loop running
* in the process which originally started up (no detach, no make_child),
* which is a pretty nice debugging environment. (You'll get a SIGHUP
* early in standalone_main; just continue through. This is the server
* trying to kill off any child processes which it might have lying
* around --- Apache doesn't keep track of their pids, it just sends
* SIGHUP to the process group, ignoring it in the root process.
* Continue through and you'll be fine.).
*/
static int one_process = 0;
#ifdef DEBUG_SIGSTOP
int raise_sigstop_flags;
#endif
static int child_num;
static unsigned int my_pid; /* Linux getpid() doesn't work except in
main thread. Use this instead */
/* Keep track of the number of worker threads currently active */
static int worker_thread_count;
static int worker_thread_free_ids[HARD_THREAD_LIMIT];
static pthread_attr_t worker_thread_attr;
/* Keep track of the number of idle worker threads */
static int idle_thread_count;
/* Locks for accept serialization */
#ifdef NO_SERIALIZED_ACCEPT
#else
static ap_lock_t *process_accept_mutex;
#endif /* NO_SERIALIZED_ACCEPT */
static const char *lock_fname;
API_EXPORT(int) ap_get_max_daemons(void)
{
return ap_max_daemons_limit;
}
/* a clean exit from a child with proper cleanup */
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.
*/
}
{
clean_child_exit(0);
}
/*****************************************************************
* Connection structures and accounting...
*/
/* volatile just in case */
static int volatile shutdown_pending;
static int volatile restart_pending;
static int volatile is_graceful;
/*
* 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.
*/
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 */
void ap_start_restart(int graceful)
{
if (restart_pending == 1) {
/* Probably not an error - don't bother reporting it */
return;
}
restart_pending = 1;
}
{
}
{
#ifndef WIN32
#else
ap_start_restart(1);
#endif
}
static void set_signals(void)
{
#ifndef NO_USE_SIGACTION
if (!one_process) {
#if defined(SA_ONESHOT)
#elif defined(SA_RESETHAND)
#endif
#ifdef SIGBUS
#endif
#ifdef SIGABORT
#endif
#ifdef SIGABRT
#endif
#ifdef SIGILL
#endif
}
#ifdef SIGINT
#endif
#ifdef SIGXCPU
#endif
#ifdef SIGXFSZ
#endif
#ifdef SIGPIPE
#endif
/* we want to ignore HUPs and WINCH while we're busy processing one */
#else
if (!one_process) {
#ifdef SIGBUS
#endif /* SIGBUS */
#ifdef SIGABORT
#endif /* SIGABORT */
#ifdef SIGABRT
#endif /* SIGABRT */
#ifdef SIGILL
#endif /* SIGILL */
#ifdef SIGXCPU
#endif /* SIGXCPU */
#ifdef SIGXFSZ
#endif /* SIGXFSZ */
}
#ifdef SIGHUP
#endif /* SIGHUP */
#ifdef SIGWINCH
#endif /* SIGWINCH */
#ifdef SIGPIPE
#endif /* SIGPIPE */
#endif
}
/*****************************************************************
* 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.
*/
{
int csd;
}
if (csd >= FD_SETSIZE) {
"new file descriptor %d is too large; you probably need "
"to rebuild Apache with a larger FD_SETSIZE "
"(currently %d)",
csd, FD_SETSIZE);
return;
}
conn_id);
}
static void *worker_thread(void *);
/* Starts a thread as long as we're below max_threads */
static int start_thread(void)
{
if (worker_thread_count < max_threads) {
"pthread_create: unable to create worker 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 if we exit. */
sleep(10);
workers_may_exit = 1;
return 0;
}
else {
}
}
else {
static int reported = 0;
if (!reported) {
"server reached MaxThreadsPerChild setting, consider raising the"
" MaxThreadsPerChild or NumServers settings");
reported = 1;
}
return 0;
}
return 1;
}
/* Sets workers_may_exit if we received a character on the pipe_of_death */
static void check_pipe_of_death(void)
{
if (!workers_may_exit) {
int ret;
char pipe_read_char;
ap_ssize_t n = 1;
/* It lost the lottery. It must continue to suffer
* through a life of servitude. */
}
else {
/* It won the lottery (or something else is very
* wrong). Embrace death with open arms. */
workers_may_exit = 1;
}
}
}
/* idle_thread_count should be incremented before starting a worker_thread */
static void *worker_thread(void *arg)
{
int srv;
int curr_pollfd, last_pollfd = 0;
int thread_just_started = 1;
int thread_num = *((int *) arg);
int n;
for(n=0 ; n <= num_listenfds ; ++n)
while (!workers_may_exit) {
if (workers_may_exit) break;
if (!thread_just_started) {
if (idle_thread_count < max_spare_threads) {
}
else {
break;
}
}
else {
thread_just_started = 0;
}
if (workers_may_exit) {
break;
}
!= APR_SUCCESS) {
"ap_lock failed. Attempting to shutdown "
"process gracefully.");
workers_may_exit = 1;
}
while (!workers_may_exit) {
if (srv != APR_SUCCESS) {
continue;
}
/* ap_poll() will only return errors in catastrophic
* circumstances. Let's try exiting gracefully, for now. */
ap_server_conf, "ap_poll: (listen)");
workers_may_exit = 1;
}
if (workers_may_exit) break;
if (event & APR_POLLIN) {
/* A process got a signal on the shutdown pipe. Check if we're
* the lucky process to die. */
continue;
}
if (num_listenfds == 1) {
goto got_fd;
}
else {
/* find a listener */
do {
curr_pollfd++;
if (curr_pollfd > num_listenfds) {
curr_pollfd = 1;
}
/* XXX: Should we check for POLLERR? */
if (event & APR_POLLIN) {
goto got_fd;
}
} while (curr_pollfd != last_pollfd);
}
}
if (!workers_may_exit) {
}
!= APR_SUCCESS) {
"ap_unlock failed. Attempting to shutdown "
"process gracefully.");
workers_may_exit = 1;
}
if (idle_thread_count > min_spare_threads) {
}
else {
if (!start_thread()) {
}
}
} else {
!= APR_SUCCESS) {
"ap_unlock failed. Attempting to shutdown "
"process gracefully.");
workers_may_exit = 1;
}
break;
}
}
if (worker_thread_count == 0) {
/* All the threads have exited, now finish the shutdown process
* by signalling the sigwait thread */
}
return NULL;
}
static void child_main(int child_num_arg)
{
int signal_received;
int i;
/*stuff to do before we switch id's, so we have permissions.*/
pchild));
if (rv != APR_SUCCESS) {
"Couldn't initialize cross-process lock in child");
}
if (unixd_setup_child()) {
}
/*done with init critical section */
/* All threads should mask signals out, accoring to sigwait(2) man page */
#ifdef SIGPROCMASK_SETS_THREAD_MASK
}
#else
"pthread_sigmask");
}
#endif
/* Set up the pollfd array */
#endif
/* Setup worker threads */
if (threads_to_start > max_threads) {
}
worker_thread_count = 0;
for (i = 0; i < max_threads; i++) {
worker_thread_free_ids[i] = i;
}
{
int on = 1;
}
#else
#endif
/* We are creating worker threads right now */
for (i=0; i < threads_to_start; i++) {
/* start_thread shouldn't fail here */
if (!start_thread()) {
break;
}
}
/* This thread will be the one responsible for handling signals */
switch (signal_received) {
case SIGTERM:
case SIGINT:
break;
default:
"received impossible signal: %d", signal_received);
}
}
{
int pid;
}
if (one_process) {
set_signals();
}
"fork: Unable to fork new process");
/* 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. */
sleep(10);
return -1;
}
if (!pid) {
#ifdef AIX_BIND_PROCESSOR
/* By default, AIX binds to a single processor. This bit unbinds
children which will then bind to another CPU.
*/
#include <sys/processor.h>
#endif
/* XXX - For an unthreaded server, a signal handler will be necessary
ap_signal(SIGTERM, just_die);
*/
return 0;
}
/* else */
return 0;
}
/* start up a bunch of children */
static int startup_children(int number_to_start)
{
int i;
for (i = 0; number_to_start && i < num_daemons; ++i) {
continue;
}
if (make_child(ap_server_conf, i, 0) < 0) {
break;
}
}
return number_to_start;
}
/*
* spawn_rate is the number of children that will be spawned on the
* next maintenance cycle if there aren't enough 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_child_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 < num_daemons; ++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) {
}
/* 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_children_to_start)
{
int child_slot;
int i;
while (!restart_pending && !shutdown_pending) {
/* non-fatal death... note that it's gone in the child table and
* clean out the status table. */
child_slot = -1;
for (i = 0; i < ap_max_daemons_limit; ++i) {
int j;
child_slot = i;
for (j = 0; j < HARD_THREAD_LIMIT; j++) {
}
break;
}
}
if (child_slot >= 0) {
&& child_slot < num_daemons) {
/* 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
* child table. Somehow we don't know about this
* child.
*/
"long lost child came home! (pid %ld)",
}
/* 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_children_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;
}
}
}
{
int i;
ap_server_conf = s;
!= APR_SUCCESS) {
(const server_rec*) ap_server_conf,
"ap_create_pipe (pipe_of_death)");
exit(1);
}
(const server_rec*) ap_server_conf,
"ap_set_pipe_timeout (pipe_of_death)");
exit(1);
}
ap_server_conf = s;
/* XXX: hey, what's the right way for the mpm to indicate a fatal error? */
"no listening sockets available, shutting down");
return 1;
}
/* Initialize cross-process accept lock */
my_pid);
if (rv != APR_SUCCESS) {
"Couldn't create cross-process lock");
return 1;
}
if (!is_graceful) {
}
/* Initialize the child table */
if (!is_graceful) {
for (i = 0; i < HARD_SERVER_LIMIT; i++) {
}
}
set_signals();
/* If we're doing a graceful_restart then we're going to see a lot
* of children exiting immediately when we get into the main loop
* below (because we just sent them SIGWINCH). This happens pretty
* rapidly... and for each one that exits we'll start a new one until
* we reach at least daemons_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.
*/
if (!is_graceful) {
}
else {
/* give the system some time to recover before kicking into
* exponential mode */
}
"%s configured -- resuming normal operations",
"Server built: %s", ap_get_server_built());
restart_pending = shutdown_pending = 0;
if (shutdown_pending) {
/* Time to gracefully shut down:
* Kill child processes, tell them to call child_exit, etc...
*/
"killpg SIGTERM");
}
/* cleanup pid file on normal shutdown */
{
"removed PID file %s (pid=%ld)",
}
ap_server_conf, "caught SIGTERM, shutting down");
return 1;
}
/* we've been told to restart */
if (one_process) {
/* not worth thinking about */
return 1;
}
if (is_graceful) {
char char_of_death = '!';
"SIGWINCH received. Doing graceful restart");
/* This is mostly for debugging... so that we know what is still
* gracefully dealing with existing request.
*/
for (i = 0; i < num_daemons; ++i) {
}
}
/* give the children the signal to die */
for (i = 0; i < num_daemons;) {
"write pipe_of_death");
}
i++;
}
}
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.
*/
"killpg SIGTERM");
}
ap_server_conf, "SIGHUP received. Attempting to restart");
}
return 0;
}
{
static int restart_num = 0;
/* sigh, want this only the second time around */
if (restart_num++ == 1) {
is_graceful = 0;
if (!one_process) {
ap_detach();
}
}
}
static void dexter_hooks(void)
{
one_process = 0;
}
{
return err;
}
return "PidFile directive not allowed in <VirtualHost>";
}
ap_pid_fname = arg;
return NULL;
}
{
return err;
}
return NULL;
}
{
return err;
}
lock_fname = arg;
return NULL;
}
{
return err;
}
if (num_daemons > HARD_SERVER_LIMIT) {
"WARNING: NumServers of %d exceeds compile time limit "
" lowering NumServers to %d. To increase, please "
"see the", HARD_SERVER_LIMIT);
" HARD_SERVER_LIMIT define in %s.",
}
else if (num_daemons < 1) {
"WARNING: Require NumServers > 0, setting to 1");
num_daemons = 1;
}
return NULL;
}
{
return err;
}
if (threads_to_start > HARD_THREAD_LIMIT) {
"WARNING: StartThreads of %d exceeds compile time"
" limit of %d threads,", threads_to_start,
" lowering StartThreads to %d. To increase, please"
" see the", HARD_THREAD_LIMIT);
" HARD_THREAD_LIMIT define in %s.",
}
else if (threads_to_start < 1) {
"WARNING: Require StartThreads > 0, setting to 1");
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;
}
if (max_spare_threads >= HARD_THREAD_LIMIT) {
"WARNING: detected MinSpareThreads set higher than");
"HARD_THREAD_LIMIT. Resetting to %d", HARD_THREAD_LIMIT);
}
return NULL;
}
{
return err;
}
if (max_threads > HARD_THREAD_LIMIT) {
"WARNING: detected MaxThreadsPerChild set higher than");
"HARD_THREAD_LIMIT. Resetting to %d", HARD_THREAD_LIMIT);
}
return NULL;
}
{
return err;
}
return NULL;
}
{
return err;
}
return NULL;
}
{
const char *fname;
return err;
}
" does not exist or is not a directory", NULL);
}
return NULL;
}
static const command_rec dexter_cmds[] = {
"A file for logging the server process ID"),
"A file for Apache to maintain runtime process management information"),
"The lockfile used when Apache needs to lock the accept() call"),
"Number of children alive at the same time"),
"Number of threads each child creates"),
"Minimum number of idle threads per child, to handle request spikes"),
"Maximum number of idle threads per child"),
"Maximum number of threads per child"),
"Maximum number of requests a particular child serves before dying."),
"Whether or not to maintain status information on current connections"),
"The location of the directory Apache changes to before dumping core"),
{ 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 */
dexter_cmds, /* command ap_table_t */
NULL, /* handlers */
dexter_hooks /* register_hooks */
};