worker.c revision 3a2bc69dbf5d2afe57bcc21c554aa1e3851fb159
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 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"
#include "apr_poll.h"
#include <stdlib.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
#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 "util_mutex.h"
#include "unixd.h"
#include "util_time.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
*/
static int 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;
static int max_workers = 0;
static int server_limit = 0;
static int thread_limit = 0;
static int had_healthy_child = 0;
static int dying = 0;
static int workers_may_exit = 0;
static int start_thread_may_exit = 0;
static int listener_may_exit = 0;
static int requests_this_child;
static int num_listensocks = 0;
static int resource_shortage = 0;
static fd_queue_t *worker_queue;
static fd_queue_info_t *worker_queue_info;
static int mpm_state = AP_MPMQ_STARTING;
* allocated on first call to pre-config hook; located on
* subsequent calls to pre-config hook
*/
typedef struct worker_retained_data {
int first_server_limit;
int first_thread_limit;
int module_loads;
int sick_child_detected;
int volatile is_graceful; /* set from signal handler */
int maxclients_reported;
/*
* The max child slot ever assigned, preserved across restarts. Necessary
* to deal with MaxRequestWorkers changes across AP_SIG_GRACEFUL restarts.
* We use this value to optimize routines that have to scan the entire
* scoreboard.
*/
int max_daemons_limit;
/*
* 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.
*/
int *idle_spawn_rate;
#ifndef MAX_SPAWN_RATE
#define MAX_SPAWN_RATE (32)
#endif
static worker_retained_data *retained;
/* 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 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;
static apr_os_thread_t *listener_os_thread;
/* Locks for accept serialization */
static apr_proc_mutex_t **accept_mutex;
static apr_proc_mutex_t *child_mutex;
static ap_listen_rec *child_listen;
static int *bucket; /* bucket array for the httpd child processes */
#else
#endif
/* The LISTENER_SIGNAL signal will be sent from the main thread to the
* listener thread to wake it up for graceful termination (what a child
* process from an old generation does when the admin does "apachectl
* graceful"). This signal will be blocked in all threads of a child
* process except for the listener thread.
*/
#define LISTENER_SIGNAL SIGHUP
/* The WORKER_SIGNAL signal will be sent from the main thread to the
* worker threads during an ungraceful restart or shutdown.
* This ensures that on systems (i.e., Linux) where closing the worker
* socket doesn't awake the worker thread when it is polling on the socket
* (especially in apr_wait_for_io_or_timeout() when handling
* Keep-Alive connections), close_worker_sockets() and join_workers()
* still function in timely manner and allow ungraceful shutdowns to
* proceed to completion. Otherwise join_workers() doesn't return
* before the main process decides the child process is non-responsive
* and sends a SIGKILL.
*/
#define WORKER_SIGNAL AP_SIG_GRACEFUL
/* An array of socket descriptors in use by each thread used to
* perform a non-graceful (forced) shutdown of the server. */
static apr_socket_t **worker_sockets;
static void close_worker_sockets(void)
{
int i;
for (i = 0; i < threads_per_child; i++) {
if (worker_sockets[i]) {
worker_sockets[i] = NULL;
}
}
}
static void wakeup_listener(void)
{
listener_may_exit = 1;
if (!listener_os_thread) {
/* XXX there is an obscure path that this doesn't handle perfectly:
* right after listener thread is created but before
* listener_os_thread is set, the first worker thread hits an
* error and starts graceful termination
*/
return;
}
/* unblock the listener if it's waiting for a worker */
/*
* we should just be able to "kill(ap_my_pid, LISTENER_SIGNAL)" on all
* platforms and wake up the listener thread since it is the only thread
* with SIGHUP unblocked, but that doesn't work on Linux
*/
#ifdef HAVE_PTHREAD_KILL
#else
#endif
}
#define ST_INIT 0
#define ST_GRACEFUL 1
#define ST_UNGRACEFUL 2
static int terminate_mode = ST_INIT;
static void signal_threads(int mode)
{
if (terminate_mode == mode) {
return;
}
/* in case we weren't called from the listener thread, wake up the
* listener thread
*/
/* for ungraceful termination, let the workers exit now;
* for graceful termination, the listener thread will notify the
* workers to exit once it has stopped accepting new connections
*/
if (mode == ST_UNGRACEFUL) {
workers_may_exit = 1;
close_worker_sockets(); /* forcefully kill all current connections */
}
}
{
*rv = APR_SUCCESS;
switch (query_code) {
case AP_MPMQ_MAX_DAEMON_USED:
break;
case AP_MPMQ_IS_THREADED:
*result = AP_MPMQ_STATIC;
break;
case AP_MPMQ_IS_FORKED:
break;
*result = server_limit;
break;
*result = thread_limit;
break;
case AP_MPMQ_MAX_THREADS:
break;
*result = 0;
break;
break;
*result = 0;
break;
break;
break;
case AP_MPMQ_MAX_DAEMONS:
break;
case AP_MPMQ_MPM_STATE:
break;
case AP_MPMQ_GENERATION:
break;
default:
*rv = APR_ENOTIMPL;
break;
}
return OK;
}
{
}
else {
}
}
{
}
{
" (quiescing)" : "");
/* Don't forget about this exiting child process, or we
* won't be able to kill it if it doesn't exit by the
* time the server is shut down.
*/
}
static const char *worker_get_name(void)
{
return "worker";
}
/* a clean exit from a child with proper cleanup */
static void clean_child_exit(int code)
{
if (pchild) {
}
if (one_process) {
worker_note_child_killed(/* slot */ 0, 0, 0);
}
}
{
clean_child_exit(0);
}
/*****************************************************************
* Connection structures and accounting...
*/
static int child_fatal;
/* volatile because they're updated from a signal handler */
static int volatile shutdown_pending;
static int volatile restart_pending;
/*
* 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 appropriate. 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(int graceful)
{
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;
}
{
}
{
}
static void set_signals(void)
{
#ifndef NO_USE_SIGACTION
#endif
if (!one_process) {
}
#ifndef NO_USE_SIGACTION
"sigaction(SIGTERM)");
#ifdef AP_SIG_GRACEFUL_STOP
#endif
#ifdef SIGINT
"sigaction(SIGINT)");
#endif
#ifdef SIGXCPU
"sigaction(SIGXCPU)");
#endif
#ifdef SIGXFSZ
/* For systems following the LFS standard, ignoring SIGXFSZ allows
* a write() beyond the 2GB limit to fail gracefully with E2BIG
* rather than terminate the process. */
"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 SIGXCPU
#endif /* SIGXCPU */
#ifdef SIGXFSZ
#endif /* SIGXFSZ */
}
#ifdef SIGHUP
#endif /* SIGHUP */
#ifdef AP_SIG_GRACEFUL
#endif /* AP_SIG_GRACEFUL */
#ifdef AP_SIG_GRACEFUL_STOP
#endif /* AP_SIG_GRACEFUL_STOP */
#ifdef SIGPIPE
#endif /* SIGPIPE */
#endif
}
/*****************************************************************
* Here follows a long bunch of generic server bookkeeping stuff...
*/
/*****************************************************************
* Child process main loop.
*/
int my_child_num,
{
if (current_conn) {
}
}
/* requests_this_child has gone to zero or below. See if the admin coded
"MaxConnectionsPerChild 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 {
}
}
static void unblock_signal(int sig)
{
#if defined(SIGPROCMASK_SETS_THREAD_MASK)
#else
#endif
}
static void dummy_signal_handler(int sig)
{
/* XXX If specifying SIG_IGN is guaranteed to unblock a syscall,
* then we don't need this goofy function.
*/
}
{
int level = APLOG_EMERG;
}
else if (requests_this_child == INT_MAX
&& ap_max_requests_per_child)) {
"apr_proc_mutex_%s failed "
"before this child process served any requests.",
func);
}
"apr_proc_mutex_%s failed. Attempting to "
"shutdown process gracefully.", func);
}
{
int have_idle_worker = 0;
int last_poll_idx = 0;
if (rv != APR_SUCCESS) {
"Couldn't create pollset in thread;"
" check system or user limits");
/* let the parent decide how bad this really is */
}
apr_pollfd_t pfd = { 0 };
if (rv != APR_SUCCESS) {
"Couldn't create add listener to pollset;"
" check system or user limits");
/* let the parent decide how bad this really is */
}
}
/* Unblock the signal used to wake this thread up, and set a handler for
* it.
*/
/* 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 (listener_may_exit) break;
if (!have_idle_worker) {
/* the following pops a recycled ptrans pool off a stack
* if there is one, in addition to reserving a worker thread
*/
&ptrans);
if (APR_STATUS_IS_EOF(rv)) {
break; /* we've been signaled to die now */
}
else if (rv != APR_SUCCESS) {
"apr_queue_info_wait failed. Attempting to "
" shutdown process gracefully.");
break;
}
have_idle_worker = 1;
}
/* We've already decremented the idle worker count inside
* ap_queue_info_wait_for_idler. */
!= APR_SUCCESS) {
if (!listener_may_exit) {
}
break; /* skip the lock release */
}
if (!child_listen->next) {
/* Only one listener, so skip the poll */
lr = child_listen;
}
else {
while (!listener_may_exit) {
const apr_pollfd_t *pdesc;
if (rv != APR_SUCCESS) {
if (APR_STATUS_IS_EINTR(rv)) {
continue;
}
/* apr_pollset_poll() will only return errors in catastrophic
* circumstances. Let's try exiting gracefully, for now. */
"apr_pollset_poll: (listen)");
}
if (listener_may_exit) break;
/* 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
*/
break;
} /* while */
if (!listener_may_exit) {
/* we can't use a recycled transaction pool this time.
* create a new transaction pool */
}
if (rv == APR_EGENERAL) {
/* E[NM]FILE, ENOMEM, etc */
resource_shortage = 1;
}
!= APR_SUCCESS) {
if (listener_may_exit) {
break;
}
}
if (rv) {
/* trash the connection; we couldn't queue the connected
* socket to a worker
*/
"ap_queue_push failed");
}
else {
have_idle_worker = 0;
}
}
}
else {
!= APR_SUCCESS) {
int level = APLOG_EMERG;
}
"apr_proc_mutex_unlock failed. Attempting to "
"shutdown process gracefully.");
}
break;
}
}
dying = 1;
/* wake up the main thread */
return NULL;
}
/* XXX For ungraceful termination/restart, we definitely don't want to
* wait for active connections to finish but we may want to wait
* for idle workers to get out of the queue code and release mutexes,
* since those mutexes are cleaned up pretty soon and some systems
* may not react favorably (i.e., segfault) if operations are attempted
* on cleaned-up mutexes.
*/
{
int is_idle = 0;
#ifdef HAVE_PTHREAD_KILL
#endif
while (!workers_may_exit) {
if (!is_idle) {
last_ptrans = NULL;
if (rv != APR_SUCCESS) {
"ap_queue_info_set_idle failed. Attempting to "
"shutdown process gracefully.");
break;
}
is_idle = 1;
}
if (workers_may_exit) {
break;
}
if (rv != APR_SUCCESS) {
/* We get APR_EOF during a graceful shutdown once all the connections
* accepted by this server process have been handled.
*/
if (APR_STATUS_IS_EOF(rv)) {
break;
}
/* We get APR_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.
*
* If workers_may_exit is set and this is ungraceful termination/
* restart, we are bound to get an error on some systems (e.g.,
* AIX, which sanity-checks mutex operations) since the queue
* may have already been cleaned up. Don't log the "error" if
* workers_may_exit is set.
*/
else if (APR_STATUS_IS_EINTR(rv)) {
goto worker_pop;
}
/* We got some other error. */
else if (!workers_may_exit) {
"ap_queue_pop failed");
}
continue;
}
is_idle = 0;
}
return NULL;
}
static int check_signal(int signum)
{
switch (signum) {
case SIGTERM:
case SIGINT:
return 1;
}
return 0;
}
{
if (rv != APR_SUCCESS) {
"apr_thread_create: unable to create listener thread");
/* let the parent decide how bad this really is */
}
}
/* XXX under some circumstances not understood, children can get stuck
* in start_threads forever trying to take over slots which will
* never be cleaned up; for now there is an APLOG_DEBUG message issued
* every so often when this condition occurs
*/
{
int my_child_num = child_num_arg;
int i;
int threads_created = 0;
int listener_started = 0;
int loops;
int prev_threads_created;
/* We must create the fd queues before we start up the listener
* and worker threads. */
if (rv != APR_SUCCESS) {
"ap_queue_init() failed");
}
if (rv != APR_SUCCESS) {
"ap_queue_info_create() failed");
}
* sizeof(apr_socket_t *));
loops = prev_threads_created = 0;
while (1) {
/* threads_per_child does not include the listener thread */
for (i = 0; i < threads_per_child; i++) {
continue;
}
/* 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");
/* let the parent decide how bad this really is */
}
}
/* Start the listener only when there are workers available */
if (!listener_started && threads_created) {
listener_started = 1;
}
break;
}
/* wait for previous generation to clean up an entry */
++loops;
if (prev_threads_created == threads_created) {
"slots very quickly (%d of %d)",
}
}
}
/* 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;
}
int mode)
{
int i;
if (listener) {
int iter;
/* deal with a rare timing window which affects waking up the
* listener thread... if the signal sent to the listener thread
* is delivered between the time it verifies that the
* listener_may_exit flag is clear and the time it enters a
* blocking syscall, the signal didn't do any good... work around
* that by sleeping briefly and sending it again
*/
iter = 0;
while (iter < 10 &&
#ifdef HAVE_PTHREAD_KILL
#else
#endif
== 0) {
/* listener not dead yet */
++iter;
}
if (iter >= 10) {
"the listener thread didn't exit");
}
else {
if (rv != APR_SUCCESS) {
"apr_thread_join: unable to join listener thread");
}
}
}
for (i = 0; i < threads_per_child; i++) {
if (threads[i]) { /* if we ever created this thread */
if (mode != ST_GRACEFUL) {
#ifdef HAVE_PTHREAD_KILL
#endif
}
if (rv != APR_SUCCESS) {
"apr_thread_join: unable to join worker "
"thread %d",
i);
}
}
}
}
{
* trying to take over slots from a
* previous generation
*/
if (rv != APR_SUCCESS) {
"apr_thread_join: unable to join the start "
"thread");
}
}
static void child_main(int child_num_arg)
{
int i;
* child initializes
*/
/* close unused listeners and pods */
for (i = 0; i < num_buckets; i++) {
if (i != bucket[child_num_arg]) {
lr = mpm_listen[i];
while(lr) {
}
mpm_listen[i]->active = 0;
ap_mpm_podx_close(pod[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");
}
}
/* done with init critical section */
/* Just use the standard apr_setup_signal_thread to block all signals
* from being received. The child processes no longer use signals for
* any communication with the parent process.
*/
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 *) * threads_per_child);
/* 0 means PTHREAD_CREATE_JOINABLE */
if (ap_thread_stacksize != 0) {
"inappropriate, using default",
}
}
if (rv != APR_SUCCESS) {
"apr_thread_create: unable to create worker thread");
/* let the parent decide how bad this really is */
}
/* If we are only running in one_process mode, we will want to
* still handle signals. */
if (one_process) {
/* Block until we get a terminating signal. */
/* make sure the start thread has finished; signal_threads()
* and join_workers() depend on that
*/
/* XXX join_start_thread() won't be awakened if one of our
* threads encounters a critical error and attempts to
* shutdown this child
*/
* quickly than 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).
*/
}
else { /* !one_process */
/* remove SIGTERM from the set of blocked signals... if one of
* the other threads in the process needs to take us down
* (e.g., for MaxConnectionsPerChild) it will send us SIGTERM
*/
/* Watch for any messages from the parent over the POD */
while (1) {
if (rv == AP_MPM_PODX_NORESTART) {
/* see if termination was triggered while we slept */
switch(terminate_mode) {
case ST_GRACEFUL:
break;
case ST_UNGRACEFUL:
break;
}
}
/* make sure the start thread has finished;
* signal_threads() and join_workers depend on that
*/
break;
}
}
/* 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).
*/
}
}
{
int pid;
}
if (one_process) {
set_signals();
/* NOTREACHED */
}
"fork: Unable to fork new process");
/* fork didn't succeed. There's no need to touch the scoreboard;
* if we were trying to replace a failed child process, then
* server_main_loop() marked its workers SERVER_DEAD, and if
* we were trying to replace a child process that exited normally,
* its worker_thread()s left SERVER_DEAD or SERVER_GRACEFUL behind.
*/
/* 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. */
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");
#endif
/* NOTREACHED */
}
/* else */
/* This new child process is squatting on the scoreboard
* entry owned by an exiting child process, which cannot
* exit until all active requests complete.
*/
}
return 0;
}
/* 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;
}
bucket[i] = i % num_buckets;
if (make_child(ap_server_conf, i) < 0) {
break;
}
}
}
static void perform_idle_server_maintenance(int child_bucket)
{
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;
int active_thread_count = 0;
/* 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 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;
int child_threads_active = 0;
if (i >= retained->max_daemons_limit && totally_free_length == retained->idle_spawn_rate[child_bucket])
/* short cut if all active processes have been examined and
* enough empty scoreboard slots have been found
*/
break;
for (j = 0; j < 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.
*/
loop if no pid? not much else matters */
if (status <= SERVER_READY &&
bucket[i] == child_bucket) {
}
}
}
}
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;
}
else if (child_threads_active == threads_per_child) {
had_healthy_child = 1;
}
/* XXX if (!ps->quiescing) is probably more reliable GLA */
if (!any_dying_threads) {
last_non_dead = i;
}
}
if (retained->sick_child_detected) {
if (had_healthy_child) {
/* Assume this is a transient error, even though it may not be. Leave
* the server up in case it is able to serve some requests or the
* problem will be resolved.
*/
retained->sick_child_detected = 0;
}
else {
/* looks like a basket case, as no child ever fully initialized; give up.
*/
shutdown_pending = 1;
child_fatal = 1;
"A resource shortage or other unrecoverable failure "
"was encountered before any child process initialized "
"successfully... httpd is exiting!");
/* the child already logged the failure details */
return;
}
}
/* Kill off one child */
}
/* terminate the free list */
if (free_length == 0) { /* scoreboard is full, can't fork */
/* no threads are "inactive" - starting, stopping, etc. */
/* have we reached MaxRequestWorkers, or just getting close? */
if (0 == idle_thread_count) {
if (!retained->maxclients_reported) {
/* only report this condition once */
"server reached MaxRequestWorkers "
"setting, consider raising the "
"MaxRequestWorkers setting");
}
} else {
if (!retained->near_maxclients_reported) {
"server is within MinSpareThreads of "
"MaxRequestWorkers, consider raising the "
"MaxRequestWorkers setting");
}
}
}
else {
"scoreboard is full, not at MaxRequestWorkers");
}
}
else {
}
"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 {
}
}
static void server_main_loop(int remaining_children_to_start)
{
int child_slot;
int status, processed_status;
int i;
while (!restart_pending && !shutdown_pending) {
if (processed_status == APEXIT_CHILDFATAL) {
/* fix race condition found in PR 39311
* A child created at the same time as a graceful happens
* can find the lock missing and create a fatal error.
* It is not fatal for the last generation to be in this state.
*/
if (child_slot < 0
== retained->my_generation) {
shutdown_pending = 1;
child_fatal = 1;
return;
}
else {
"Ignoring fatal error in child of previous "
"generation (pid %ld).",
}
}
else if (processed_status == APEXIT_CHILDSICK) {
/* tell perform_idle_server_maintenance to check into this
* on the next timer pop
*/
}
/* non-fatal death... note that it's gone in the scoreboard. */
if (child_slot >= 0) {
for (i = 0; i < threads_per_child; i++)
(request_rec *) NULL);
worker_note_child_killed(child_slot, 0, 0);
if (processed_status == APEXIT_CHILDSICK) {
/* resource shortage, minimize the fork rate */
}
else if (remaining_children_to_start
&& child_slot < ap_daemons_limit) {
/* we're still doing a 1-for-1 replacement of dead
* children with new children
*/
}
}
if (processed_status == APEXIT_CHILDSICK
/* resource shortage, minimize the fork rate */
for (i = 0; i < num_buckets; i++) {
}
}
}
status) == 0) {
/* handled */
#endif
}
else if (retained->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;
}
for (i = 0; i < num_buckets; i++) {
}
}
}
{
int i;
/* Initialize cross-process accept lock */
for (i = 0; i < num_buckets; i++) {
s, _pconf, 0);
if (rv != APR_SUCCESS) {
return DONE;
}
}
}
if (!retained->is_graceful) {
return DONE;
}
/* fix the generation number in the global score; we just got a new,
* cleared scoreboard
*/
}
restart_pending = shutdown_pending = 0;
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 may start a new one, until
* there are at least min_spare_threads idle threads, counting across
* all children. But we may be permitted to start more children 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 (!retained->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());
ap_log_command_line(plog, s);
ap_log_common(s);
"Accept mutex: %s (default: %s)",
/* Time to shut down:
* Kill child processes, tell them to call child_exit, etc...
*/
for (i = 0; i < num_buckets; i++) {
}
if (!child_fatal) {
/* cleanup pid file on normal shutdown */
}
return DONE;
} else if (shutdown_pending) {
/* Time to gracefully shut down:
* Kill child processes, tell them to call child_exit, etc...
*/
int active_children;
int index;
apr_time_t cutoff = 0;
/* Close our listeners, and then ask our children to do same */
for (i = 0; i < num_buckets; i++) {
}
if (!child_fatal) {
/* cleanup pid file on normal shutdown */
"caught " AP_SIG_GRACEFUL_STOP_STRING
", shutting down gracefully");
}
if (ap_graceful_shutdown_timeout) {
cutoff = apr_time_now() +
}
/* Don't really exit until each child has finished */
shutdown_pending = 0;
do {
/* Pause for a second */
/* Relieve any children which have now exited */
active_children = 0;
active_children = 1;
/* Having just one child is enough to stay around */
break;
}
}
} while (!shutdown_pending && active_children &&
/* We might be here because we received SIGTERM, either
* way, try and make sure that all of our processes are
* really dead.
*/
for (i = 0; i < num_buckets; i++) {
}
return DONE;
}
/* we've been told to restart */
if (one_process) {
/* not worth thinking about */
return DONE;
}
/* 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.
*/
if (retained->is_graceful) {
AP_SIG_GRACEFUL_STRING " received. Doing graceful restart");
/* wake up the children...time to die. But we'll have more soon */
for (i = 0; i < num_buckets; i++) {
}
/* 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.
*/
for (i = 0; i < num_buckets; i++) {
}
"SIGHUP received. Attempting to restart");
}
return OK;
}
/* This really should be a post_config hook, but the error log is already
* redirected by that point, so we need to do this in the open_logs phase.
*/
{
int startup = 0;
int level_flags = 0;
int i;
int num_of_cores = 0;
pconf = p;
/* the reverse of pre_config, we want this only the first time around */
startup = 1;
}
"no listening sockets available, shutting down");
return DONE;
}
if (have_so_reuseport) {
#ifdef _SC_NPROCESSORS_ONLN
#else
num_of_cores = 1;
#endif
if (num_of_cores > 8) {
}
else {
num_buckets = 1;
}
}
else {
num_buckets = 1;
}
if (!one_process) {
for (i = 0; i < num_buckets; i++) {
"could not open pipe-of-death");
return DONE;
}
}
}
return OK;
}
{
const char *userdata_key = "mpm_worker_module";
int i;
if (debug) {
no_detach = 0;
}
else {
}
/* sigh, want this only the second time around */
if (!retained) {
}
++retained->module_loads;
if (!one_process && !foreground) {
/* before we detach, setup crash handlers to log to errorlog */
if (rv != APR_SUCCESS) {
"apr_proc_detach failed");
return HTTP_INTERNAL_SERVER_ERROR;
}
for (i = 0; i< num_buckets; i++) {
}
}
}
had_healthy_child = 0;
ap_extended_status = 0;
return OK;
}
{
int startup = 0;
/* the reverse of pre_config, we want this only the first time around */
startup = 1;
}
if (server_limit > MAX_SERVER_LIMIT) {
if (startup) {
"WARNING: ServerLimit of %d exceeds compile-time "
"limit of", server_limit);
" %d servers, decreasing to %d.",
} else {
"ServerLimit of %d exceeds compile-time limit "
"of %d, decreasing to match",
}
}
else if (server_limit < 1) {
if (startup) {
"WARNING: ServerLimit of %d not allowed, "
"increasing to 1.", server_limit);
} else {
"ServerLimit of %d not allowed, increasing to 1",
}
server_limit = 1;
}
/* you cannot change ServerLimit across a restart; ignore
* any such attempts
*/
if (!retained->first_server_limit) {
}
/* don't need a startup console version here */
"changing ServerLimit to %d from original value of %d "
"not allowed during restart",
}
if (thread_limit > MAX_THREAD_LIMIT) {
if (startup) {
"WARNING: ThreadLimit of %d exceeds compile-time "
"limit of", thread_limit);
" %d threads, decreasing to %d.",
} else {
"ThreadLimit of %d exceeds compile-time limit "
"of %d, decreasing to match",
}
}
else if (thread_limit < 1) {
if (startup) {
"WARNING: ThreadLimit of %d not allowed, "
"increasing to 1.", thread_limit);
} else {
"ThreadLimit of %d not allowed, increasing to 1",
}
thread_limit = 1;
}
/* you cannot change ThreadLimit across a restart; ignore
* any such attempts
*/
if (!retained->first_thread_limit) {
}
/* don't need a startup console version here */
"changing ThreadLimit to %d from original value of %d "
"not allowed during restart",
}
if (threads_per_child > thread_limit) {
if (startup) {
"WARNING: ThreadsPerChild of %d exceeds ThreadLimit "
"of", threads_per_child);
" %d threads, decreasing to %d.",
" To increase, please see the ThreadLimit "
"directive.");
} else {
"ThreadsPerChild of %d exceeds ThreadLimit "
"of %d, decreasing to match",
}
}
else if (threads_per_child < 1) {
if (startup) {
"WARNING: ThreadsPerChild of %d not allowed, "
"increasing to 1.", threads_per_child);
} else {
"ThreadsPerChild of %d not allowed, increasing to 1",
}
threads_per_child = 1;
}
if (max_workers < threads_per_child) {
if (startup) {
"WARNING: MaxRequestWorkers of %d is less than "
"ThreadsPerChild of", max_workers);
" %d, increasing to %d. MaxRequestWorkers must be at "
"least as large",
" as the number of threads in a single server.");
} else {
"MaxRequestWorkers of %d is less than ThreadsPerChild "
"of %d, increasing to match",
}
}
if (max_workers % threads_per_child) {
if (startup) {
"WARNING: MaxRequestWorkers of %d is not an integer "
"multiple of", max_workers);
" ThreadsPerChild of %d, decreasing to nearest "
"multiple %d,", threads_per_child,
" for a maximum of %d servers.",
} else {
"MaxRequestWorkers of %d is not an integer multiple of "
"ThreadsPerChild of %d, decreasing to nearest "
}
}
if (ap_daemons_limit > server_limit) {
if (startup) {
"WARNING: MaxRequestWorkers of %d would require %d "
" would exceed ServerLimit of %d, decreasing to %d.",
" To increase, please see the ServerLimit "
"directive.");
} else {
"MaxRequestWorkers of %d would require %d servers and "
"exceed ServerLimit of %d, decreasing to %d",
}
}
/* ap_daemons_to_start > ap_daemons_limit checked in worker_run() */
if (ap_daemons_to_start < 0) {
if (startup) {
"WARNING: StartServers of %d not allowed, "
"increasing to 1.", ap_daemons_to_start);
} else {
"StartServers of %d not allowed, increasing to 1",
}
ap_daemons_to_start = 1;
}
if (min_spare_threads < 1) {
if (startup) {
"WARNING: MinSpareThreads of %d not allowed, "
"increasing to 1", min_spare_threads);
" to avoid almost certain server failure.");
" Please read the documentation.");
} else {
"MinSpareThreads of %d not allowed, increasing to 1",
}
min_spare_threads = 1;
}
/* max_spare_threads < min_spare_threads + threads_per_child
* checked in worker_run()
*/
return OK;
}
static void worker_hooks(apr_pool_t *p)
{
/* Our open_logs hook function must run before the core's, or stderr
* will be redirected to a file, and the messages won't print to the
* console.
*/
one_process = 0;
ap_force_set_tz(p);
/* we need to set the MPM state before other pre-config hooks use MPM query
* to retrieve it, so register as REALLY_FIRST
*/
}
const char *arg)
{
return err;
}
return NULL;
}
const char *arg)
{
return err;
}
return NULL;
}
const char *arg)
{
return err;
}
return NULL;
}
const char *arg)
{
return err;
}
"MaxClients is deprecated, use MaxRequestWorkers "
"instead.");
}
return NULL;
}
const char *arg)
{
return err;
}
return NULL;
}
{
return err;
}
return NULL;
}
{
return err;
}
return NULL;
}
static const command_rec worker_cmds[] = {
"Number of child processes launched at server startup"),
"Minimum number of idle threads, to handle request spikes"),
"Maximum number of idle threads"),
"Maximum number of threads alive at the same time"),
"Deprecated name of MaxRequestWorkers"),
"Number of threads each child creates"),
"Maximum number of child processes for this run of Apache"),
"Maximum number of worker threads per child process for this run of Apache - Upper limit for ThreadsPerChild"),
{ 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 */
};