worker.c revision 26dfa083a1662d57ba7cc410eec4e0696b9be469
/* ====================================================================
* 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 purpose of this MPM is to fix the design flaws in the threaded
* model. Because of the way that pthreads and mutex locks interact,
* it is basically impossible to cleanly gracefully shutdown a child
* process if multiple threads are all blocked in accept. This model
* fixes those problems.
*/
#include "apr.h"
#include "apr_portable.h"
#include "apr_strings.h"
#include "apr_file_io.h"
#include "apr_thread_proc.h"
#include "apr_signal.h"
#include "apr_thread_mutex.h"
#include "apr_proc_mutex.h"
#define APR_WANT_STRFUNC
#include "apr_want.h"
#include <unistd.h>
#endif
#endif
#endif
#ifdef HAVE_SYS_PROCESSOR_H
#endif
#if !APR_HAS_THREADS
#endif
#define CORE_PRIVATE
#include "ap_config.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 "mpm_common.h"
#include "ap_listen.h"
#include "scoreboard.h"
#include "fdqueue.h"
#include "mpm_default.h"
#include <signal.h>
#include <limits.h> /* for INT_MAX */
/* 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 --- first off,
* in case something goes seriously wrong, we want to stop the fork bomb
* short of actually crashing the machine we're running on by filling some
* kernel table. Secondly, it keeps the size of the scoreboard file small
* enough that we can read the whole thing without worrying too much about
* the overhead.
*/
#ifndef DEFAULT_SERVER_LIMIT
#define DEFAULT_SERVER_LIMIT 16
#endif
/* Admin can't tune ServerLimit beyond MAX_SERVER_LIMIT. We want
* some sort of compile-time limit to help catch typos.
*/
#ifndef MAX_SERVER_LIMIT
#define MAX_SERVER_LIMIT 20000
#endif
/* Limit on the threads per process. Clients will be locked out if more than
* this * 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.
*/
#ifndef DEFAULT_THREAD_LIMIT
#define DEFAULT_THREAD_LIMIT 64
#endif
/* Admin can't tune ThreadLimit beyond MAX_THREAD_LIMIT. We want
* some sort of compile-time limit to help catch typos.
*/
#ifndef MAX_THREAD_LIMIT
#define MAX_THREAD_LIMIT 20000
#endif
/*
* Actual definitions of config globals
*/
int ap_threads_per_child = 0; /* Worker threads per child */
static int ap_daemons_to_start = 0;
static int min_spare_threads = 0;
static int max_spare_threads = 0;
static int ap_daemons_limit = 0; /* MaxClients */
static int server_limit = DEFAULT_SERVER_LIMIT;
static int first_server_limit;
static int thread_limit = DEFAULT_THREAD_LIMIT;
static int first_thread_limit;
static int changed_limit_at_restart;
static int dying = 0;
static int workers_may_exit = 0;
static int requests_this_child;
static int num_listensocks = 0;
static fd_queue_t *worker_queue;
/* The structure used to pass unique initialization info to each thread */
typedef struct {
int pid;
int tid;
int sd;
} proc_info;
/* Structure used to pass information to the thread responsible for
* creating the rest of the threads.
*/
typedef struct {
int child_num_arg;
#define ID_FROM_CHILD_THREAD(c, t) ((c * thread_limit) + t)
/*
* 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_daemons_limit = -1;
/* insures that a child process only consumes one character */
static apr_thread_mutex_t *pipe_of_death_mutex;
/* *Non*-shared http_main globals... */
/* The worker MPM respects a couple of runtime flags that can aid
* in debugging. Setting the -DNO_DETACH flag will prevent the root process
* from detaching from its controlling terminal. Additionally, setting
* the -DONE_PROCESS flag (which implies -DNO_DETACH) will get you the
* child_main loop running in the process which originally started up.
* This gives you 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
thread. Use this instead */
static pid_t parent_pid;
/* Keep track of the number of worker threads currently active */
static int worker_thread_count;
/* Locks for accept serialization */
static apr_proc_mutex_t *accept_mutex;
#ifdef NO_SERIALIZED_ACCEPT
#else
#endif
static void signal_workers(void)
{
workers_may_exit = 1;
/* XXX: This will happen naturally on a graceful, and we don't care
* otherwise.
ap_queue_signal_all_wakeup(worker_queue); */
}
{
switch(query_code){
case AP_MPMQ_MAX_DAEMON_USED:
return APR_SUCCESS;
case AP_MPMQ_IS_THREADED:
*result = AP_MPMQ_STATIC;
return APR_SUCCESS;
case AP_MPMQ_IS_FORKED:
return APR_SUCCESS;
*result = server_limit;
return APR_SUCCESS;
*result = thread_limit;
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;
}
/* 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)
{
if (ap_my_pid == parent_pid) {
0, ap_server_conf,
"seg fault or similar nasty error detected "
"in the parent process");
/* XXX we can probably add some rudimentary cleanup code here,
* like getting rid of the pid file. If any additional bad stuff
* happens, we are protected from recursive errors taking down the
* system since this function is no longer the signal handler GLA
*/
}
/* 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;
static volatile int child_fatal;
ap_generation_t volatile ap_my_generation;
/*
* 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 set_signals(void)
{
#ifndef NO_USE_SIGACTION
if (!one_process) {
#if defined(SA_ONESHOT)
#elif defined(SA_RESETHAND)
#endif
"sigaction(SIGSEGV)");
#ifdef SIGBUS
"sigaction(SIGBUS)");
#endif
#ifdef SIGABORT
"sigaction(SIGABORT)");
#endif
#ifdef SIGABRT
"sigaction(SIGABRT)");
#endif
#ifdef SIGILL
"sigaction(SIGILL)");
#endif
}
"sigaction(SIGTERM)");
#ifdef SIGINT
"sigaction(SIGINT)");
#endif
#ifdef SIGXCPU
"sigaction(SIGXCPU)");
#endif
#ifdef SIGXFSZ
"sigaction(SIGXFSZ)");
#endif
#ifdef SIGPIPE
"sigaction(SIGPIPE)");
#endif
/* we want to ignore HUPs and AP_SIG_GRACEFUL while we're busy
* processing one */
"sigaction(SIGHUP)");
#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 AP_SIG_GRACEFUL
#endif /* AP_SIG_GRACEFUL */
#ifdef SIGPIPE
#endif /* SIGPIPE */
#endif
}
/*****************************************************************
* Here follows a long bunch of generic server bookkeeping stuff...
*/
int ap_graceful_stop_signalled(void)
/* XXX this is really a bad confusing obsolete name
* maybe it should be ap_mpm_process_exiting?
*/
{
return workers_may_exit;
}
/*****************************************************************
* Child process main loop.
*/
int my_thread_num)
{
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;
}
if (current_conn) {
}
}
/* requests_this_child has gone to zero or below. See if the admin coded
"MaxRequestsPerChild 0", and keep going in that case. Doing it this way
simplifies the hot path in worker_thread */
static void check_infinite_requests(void)
{
if (ap_max_requests_per_child) {
}
else {
/* wow! if you're executing this code, you may have set a record.
* either this child process has served over 2 billion requests, or
* you're running a threaded 2.0 on a 16 bit machine.
*
* I'll buy pizza and beers at Apachecon for the first person to do
* the former without cheating (dorking with INT_MAX, or running with
* uncommitted performance patches, for example).
*
* for the latter case, you probably deserve a beer too. Greg Ames
*/
}
}
/* Sets workers_may_exit if we received a character on the pipe_of_death */
{
if (!workers_may_exit) {
char pipe_read_char;
apr_size_t n = 1;
if (APR_STATUS_IS_EAGAIN(ret)) {
/* 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. */
}
}
/* This is a hack to get us back to the top of the accept loop.
* we should probably have a better way to do this though.
*/
return APR_EINTR;
}
{
int n;
/* TODO: Switch to a system where threads reuse the results from earlier
poll calls - manoj */
while (1) {
/* TODO: requests_this_child should be synchronized - aaron */
if (requests_this_child <= 0) {
}
if (workers_may_exit) break;
!= APR_SUCCESS) {
"apr_proc_mutex_lock failed. Attempting to shutdown "
"process gracefully.");
}
while (!workers_may_exit) {
if (ret != APR_SUCCESS) {
if (APR_STATUS_IS_EINTR(ret)) {
continue;
}
/* apr_poll() will only return errors in catastrophic
* circumstances. Let's try exiting gracefully, for now. */
ap_server_conf, "apr_poll: (listen)");
}
if (workers_may_exit) break;
/* only one listener */
lr = ap_listeners;
goto got_fd;
}
else {
/* find a listener */
do {
lr = ap_listeners;
}
/* XXX: Should we check for POLLERR? */
if (event & APR_POLLIN) {
goto got_fd;
}
}
}
if (!workers_may_exit) {
/* create a new transaction pool for each accepted socket */
if (rv == APR_EGENERAL) {
}
!= APR_SUCCESS) {
"apr_proc_mutex_lock failed. Attempting to "
"shutdown process gracefully.");
}
if (rv) {
/* trash the connection; we couldn't queue the connected
* socket to a worker
*/
"ap_queue_push failed with error code %d",
rv);
}
}
}
else {
!= APR_SUCCESS) {
"apr_proc_mutex_unlock failed. Attempting to "
"shutdown process gracefully.");
}
break;
}
}
(request_rec *) NULL);
dying = 1;
return NULL;
}
{
while (!workers_may_exit) {
/* We get FD_QUEUE_EINTR whenever ap_queue_pop() has been interrupted
* from an explicit call to ap_queue_interrupt_all(). This allows
* us to unblock threads stuck in ap_queue_pop() when a shutdown
* is pending. */
continue;
}
requests_this_child--; /* FIXME: should be synchronized - aaron */
}
return NULL;
}
static int check_signal(int signum)
{
switch (signum) {
case SIGTERM:
case SIGINT:
return 1;
}
return 0;
}
{
int my_child_num = child_num_arg;
int i = 0;
int threads_created = 0;
/* We must create the fd queues before we start up the listener
* and worker threads. */
if (rv != APR_SUCCESS) {
"apr_thread_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);
}
while (1) {
/* ap_threads_per_child does not include the listener thread */
for (i = 0; i < ap_threads_per_child; i++) {
continue;
}
"malloc: out of memory");
}
/* We are creating threads right now */
/* We let each thread update its own scoreboard entry. This is
* done because it lets us deal with tid better.
*/
if (rv != APR_SUCCESS) {
"apr_thread_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);
}
}
break;
}
}
/* What state should this child_main process be listed as in the
* scoreboard...?
* ap_update_child_status_from_indexes(my_child_num, i, SERVER_STARTING,
* (request_rec *) NULL);
*
* This state should be listed separately in the scoreboard, in some kind
* of process_status, not mixed in with the worker threads' status.
* "life_status" is almost right, but it's in the worker's structure, and
* the name could be clearer. gla
*/
return NULL;
}
static void child_main(int child_num_arg)
{
int i;
/*stuff to do before we switch id's, so we have permissions.*/
reopen_scoreboard(pchild, 0);
pchild));
if (rv != APR_SUCCESS) {
"Couldn't initialize cross-process lock in child");
}
if (unixd_setup_child()) {
}
/* done with init critical section */
if (rv != APR_SUCCESS) {
"Couldn't initialize signal thread");
}
if (ap_max_requests_per_child) {
}
else {
/* coding a value of zero means infinity */
}
/* Setup worker threads */
/* clear the storage; we may not create all our threads immediately,
* and we want a 0 entry to indicate a thread which was not created
*/
sizeof(apr_thread_t *) * ap_threads_per_child);
"malloc: out of memory");
}
worker_thread_count = 0;
/* 0 means PTHREAD_CREATE_JOINABLE */
if (rv != APR_SUCCESS) {
"apr_thread_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);
}
signal_workers(); /* helps us terminate a little more quickly when
* the dispatch of the signal thread
* beats the Pipe of Death and the browsers
*/
/* A terminating signal was received. Now join each of the workers to
* clean them up.
* If the worker already exited, then the join frees their resources
* and returns.
* If the worker hasn't exited, then this blocks until they have (then
* cleans up).
*/
for (i = 0; i < ap_threads_per_child; i++) {
if (threads[i]) { /* if we ever created this thread */
}
}
clean_child_exit(0);
}
{
int pid;
}
if (one_process) {
set_signals();
}
"fork: Unable to fork new process");
/* fork didn't succeed. Fix the scoreboard or else
* it will say SERVER_STARTING forever and ever
*/
/* 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 HAVE_BINDPROCESSOR
/* By default, AIX binds to a single processor. This bit unbinds
* children which will then bind to another CPU.
*/
"processor unbind failed %d", status);
#endif
clean_child_exit(0);
}
/* else */
return 0;
}
/* If there aren't many connections coming in from the network, the child
* processes may need to be awakened from their network i/o waits.
* The pipe of death is an effective prod.
*/
static void wake_up_and_die(void)
{
int i;
char char_of_death = '!';
for (i = 0; i < ap_daemons_limit;) {
!= APR_SUCCESS) {
if (APR_STATUS_IS_EINTR(rv)) continue;
"write pipe_of_death");
}
i++;
}
}
/* start up a bunch of children */
static void startup_children(int number_to_start)
{
int i;
for (i = 0; number_to_start && i < ap_daemons_limit; ++i) {
continue;
}
if (make_child(ap_server_conf, i) < 0) {
break;
}
}
}
/*
* idle_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 idle_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, j;
int idle_thread_count;
int free_length;
int totally_free_length = 0;
int free_slots[MAX_SPAWN_RATE];
int last_non_dead;
int total_non_dead;
/* initialize the free_list */
free_length = 0;
idle_thread_count = 0;
last_non_dead = -1;
total_non_dead = 0;
for (i = 0; i < ap_daemons_limit; ++i) {
/* Initialization to satisfy the compiler. It doesn't know
* that ap_threads_per_child is always > 0 */
int status = SERVER_DEAD;
int any_dying_threads = 0;
int any_dead_threads = 0;
int all_dead_threads = 1;
break;
for (j = 0; j < ap_threads_per_child; j++) {
/* XXX any_dying_threads is probably no longer needed GLA */
(status == SERVER_GRACEFUL);
(status == SERVER_DEAD ||
status == SERVER_GRACEFUL);
/* We consider a starting server as idle because we started it
* at least a cycle ago, and if it still hasn't finished starting
* then we're just going to swamp things worse by forking more.
* So we hopefully won't need to fork more if we count it.
* This depends on the ordering of SERVER_READY and SERVER_STARTING.
*/
/* XXX the following shouldn't be necessary if we clean up
* properly after seg faults, but we're not yet GLA
*/
}
}
if (all_dead_threads) {
/* great! we prefer these, because the new process can
* start more threads sooner. So prioritize this slot
* by putting it ahead of any slots with active threads.
*
* first, make room by moving a slot that's potentially still
* in use to the end of the array
*/
free_slots[totally_free_length++] = i;
}
else {
/* slot is still in use - back of the bus
*/
free_slots[free_length] = i;
}
++free_length;
}
/* XXX if (!ps->quiescing) is probably more reliable GLA */
if (!any_dying_threads) {
last_non_dead = i;
}
}
if (idle_thread_count > max_spare_threads) {
char char_of_death = '!';
/* Kill off one child */
&one)) != APR_SUCCESS) {
"write pipe_of_death");
}
idle_spawn_rate = 1;
}
else if (idle_thread_count < min_spare_threads) {
/* terminate the free list */
if (free_length == 0) {
/* only report this condition once */
static int reported = 0;
if (!reported) {
"server reached MaxClients setting, consider"
" raising the MaxClients setting");
reported = 1;
}
idle_spawn_rate = 1;
}
else {
if (free_length > idle_spawn_rate) {
}
if (idle_spawn_rate >= 8) {
"server seems busy, (you may need "
"to increase StartServers, ThreadsPerChild "
"or Min/MaxSpareThreads), "
"spawning %d children, there are around %d idle "
"threads, and %d total children", free_length,
}
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 (idle_spawn_rate < MAX_SPAWN_RATE) {
idle_spawn_rate *= 2;
}
}
}
else {
idle_spawn_rate = 1;
}
}
static void server_main_loop(int remaining_children_to_start)
{
int child_slot;
int status;
int i;
while (!restart_pending && !shutdown_pending) {
status) == APEXIT_CHILDFATAL) {
shutdown_pending = 1;
child_fatal = 1;
return;
}
/* non-fatal death... note that it's gone in the scoreboard. */
if (child_slot >= 0) {
for (i = 0; i < ap_threads_per_child; i++)
(request_rec *) NULL);
&& child_slot < ap_daemons_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.
*/
"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 filedes;
if (rv != APR_SUCCESS) {
(const server_rec*) ap_server_conf,
"apr_file_pipe_create (pipe_of_death)");
exit(1);
}
(const server_rec*) ap_server_conf,
"apr_file_pipe_timeout_set (pipe_of_death)");
exit(1);
}
/* We are not bound to a real address. So, indicate that. */
ap_listeners = lr;
(*num_listeners)++;
}
{
ap_server_conf = s;
if (changed_limit_at_restart) {
"WARNING: Attempt to change ServerLimit or ThreadLimit "
"ignored during restart");
}
/* 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 */
if (rv != APR_SUCCESS) {
"Couldn't create accept lock");
return 1;
}
if (ap_accept_lock_mech == APR_LOCK_DEFAULT ||
#else
if (ap_accept_lock_mech == APR_LOCK_SYSVSEM) {
#endif
if (rv != APR_SUCCESS) {
"Couldn't set permissions on cross-process lock");
return 1;
}
}
if (!is_graceful) {
}
set_signals();
/* Don't thrash... */
/* 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 AP_SIG_GRACEFUL). 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");
}
if (!child_fatal) {
/* 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;
}
/* advance to the next generation */
/* XXX: we really need to make sure this new generation number isn't in
* use by any of the children.
*/
/* wake up the children...time to die. But we'll have more soon */
if (is_graceful) {
AP_SIG_GRACEFUL_STRING " received. Doing graceful restart");
/* This is mostly for debugging... so that we know what is still
* gracefully dealing with existing request.
*/
}
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");
}
"SIGHUP received. Attempting to restart");
}
/* get the pipe of death out of the listen_rec list */
return 0;
}
{
static int restart_num = 0;
/* make sure that "ThreadsPerChild" gets set before "MaxClients" */
if (!max_clients) {
break; /* we're in the clear, got ThreadsPerChild first */
}
else {
/* now to swap the data */
/* Make sure you don't change 'next', or you may get loops! */
/* XXX: first_child, parent, and data can never be set
* for these directives, right? -aaron */
break;
}
}
else if (!max_clients
max_clients = pdir;
}
}
if (debug)
else
{
}
/* sigh, want this only the second time around */
if (restart_num++ == 1) {
is_graceful = 0;
if (!one_process && !no_detach) {
}
}
ap_extended_status = 0;
}
static void worker_hooks(apr_pool_t *p)
{
one_process = 0;
}
const char *arg)
{
return err;
}
return NULL;
}
const char *arg)
{
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;
}
const char *arg)
{
return err;
}
return NULL;
}
const char *arg)
{
int max_clients;
return err;
}
/* It is ok to use ap_threads_per_child here because we are
* sure that it gets set before MaxClients in the pre_config stage. */
if (max_clients < ap_threads_per_child) {
"WARNING: MaxClients (%d) must be at least as large",
" large as ThreadsPerChild (%d). Automatically",
" increasing MaxClients to %d.",
}
"WARNING: MaxClients (%d) is not an integer multiple",
" of ThreadsPerChild (%d), lowering MaxClients to %d",
" for a maximum of %d child processes,",
}
if (ap_daemons_limit > server_limit) {
"WARNING: MaxClients of %d would require %d servers,",
" and would exceed the ServerLimit value of %d.",
" Automatically lowering MaxClients to %d. To increase,",
" please see the ServerLimit directive.");
}
else if (ap_daemons_limit < 1) {
"WARNING: Require MaxClients > 0, setting to 1");
ap_daemons_limit = 1;
}
return NULL;
}
const char *arg)
{
return err;
}
if (ap_threads_per_child > thread_limit) {
"WARNING: ThreadsPerChild of %d exceeds ThreadLimit "
"value of %d", ap_threads_per_child,
"threads, lowering ThreadsPerChild to %d. To increase, please"
" see the", thread_limit);
" ThreadLimit directive.");
}
else if (ap_threads_per_child < 1) {
"WARNING: Require ThreadsPerChild > 0, setting to 1");
ap_threads_per_child = 1;
}
return NULL;
}
{
int tmp_server_limit;
return err;
}
/* you cannot change ServerLimit across a restart; ignore
* any such attempts
*/
if (first_server_limit &&
tmp_server_limit != server_limit) {
/* how do we log a message? the error log is a bit bucket at this
* point; we'll just have to set a flag so that ap_mpm_run()
* logs a warning later
*/
return NULL;
}
if (server_limit > MAX_SERVER_LIMIT) {
"WARNING: ServerLimit of %d exceeds compile time limit "
" lowering ServerLimit to %d.", MAX_SERVER_LIMIT);
}
else if (server_limit < 1) {
"WARNING: Require ServerLimit > 0, setting to 1");
server_limit = 1;
}
return NULL;
}
{
int tmp_thread_limit;
return err;
}
/* you cannot change ThreadLimit across a restart; ignore
* any such attempts
*/
if (first_thread_limit &&
tmp_thread_limit != thread_limit) {
/* how do we log a message? the error log is a bit bucket at this
* point; we'll just have to set a flag so that ap_mpm_run()
* logs a warning later
*/
return NULL;
}
if (thread_limit > MAX_THREAD_LIMIT) {
"WARNING: ThreadLimit of %d exceeds compile time limit "
" lowering ThreadLimit to %d.", MAX_THREAD_LIMIT);
}
else if (thread_limit < 1) {
"WARNING: Require ThreadLimit > 0, setting to 1");
thread_limit = 1;
}
return NULL;
}
static const command_rec worker_cmds[] = {
"Number of child processes launched 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"),
"Number of threads each child creates"),
"Maximum value of MaxClients for this run of Apache"),
"Maximum worker threads in a server for this run of Apache"),
{ 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 */
worker_cmds, /* command apr_table_t */
worker_hooks /* register_hooks */
};