prefork.c revision 2fc50921b88defeb7127985dfe4b4130175e069e
* notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * 3. The end-user documentation included with the redistribution, * if any, must include the following acknowledgment: * "This product includes software developed by the * 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 * ==================================================================== * 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. #
include <
bstring.h>
/* for IRIX, FD_SET calls bzero() *//* 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 /* Admin can't tune ServerLimit beyond MAX_SERVER_LIMIT. We want * some sort of compile-time limit to help catch typos. * 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. /* 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 pid_t ap_my_pid;
/* it seems silly to call getpid all the time */ * change directory for gprof to plop the gmon.out file "gprof: error creating directory %s",
dir);
/* XXX - I don't know if TPF will ever use this module or not, so leave * the ap_check_signals calls in but disable them - manoj */ /* a clean exit from a child with proper cleanup */ /* On some architectures it's safe to do unserialized accept()s in the single * Listen case. But it's never safe to do it in the case where there's * multiple Listen statements. Define SINGLE_LISTEN_UNSERIALIZED_ACCEPT * when it's safe in the single Listen case. Systems without a real waitpid sometimes lose a child's exit while waiting for another. Search through the scoreboard for missing children. /* just mark it as having a successful exit status */ /* handle all varieties of core dumping signals */ "seg fault or similar nasty error detected " "in the parent process");
/* At this point we've got sig blocked, because we're still inside * the signal handler. When we leave the signal handler it will * be unblocked, and we'll take the signal... and coredump or whatever * is appropriate for this particular Unix. In addition the parent * will see the real signal we received -- whereas if we called * abort() here, the parent would only see SIGABRT. /***************************************************************** * Connection structures and accounting... /* volatile just in case */ /* 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. /* restart() is the signal handler for SIGHUP and AP_SIG_GRACEFUL * in the parent process, unless running in ONE_PROCESS mode /* Probably not an error - don't bother reporting it */ /* we want to ignore HUPs and AP_SIG_GRACEFUL while we're busy #
endif /* AP_SIG_GRACEFUL *//***************************************************************** * Child process main loop. * The following vars are static to avoid getting clobbered by longjmp(); * they are really private to child_main. /* not ever called anymore... */ /* Get a sub context for global allocations in this child, so that * we can have cleanups occur when the child exits. /* needs to be done before we switch UIDs so we have permissions */ "Couldn't initialize cross-process lock in child");
/* Set up the pollfd array */ * (Re)initialize this child to a pre-connection state. * Wait for an acceptable connection to arrive. /* Lock around "accept", if necessary */ /* multiple listening sockets - need to poll */ /* Single Unix documents select as returning errnos * EBADF, EINTR, and EINVAL... and in none of those * cases does it make sense to continue. In fact * on Linux 2.0.x we seem to end up with EFAULT * occasionally, and we'd loop forever due to it. /* XXX: Should we check for POLLERR? */ /* if we accept() something we don't want to die, so we have to /* resource shortage or should-not-occur occured */ * We now have a connection, so set it up with the appropriate * socket options, file descriptors, and read/write buffers. /* Check the pod and the generation number after processing a * connection so that we'll go away if a graceful restart occurred * while we were processing the connection or we are the lucky * idle server process that gets to die. /* yeah, this could be non-graceful restart, in which case the * parent will kill us soon enough, but why bother checking? /* Don't catch AP_SIG_GRACEFUL in ONE_PROCESS mode :) */ /* BS2000 requires a "special" version of fork() before a setuid() call */ /* 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 /* by default AIX binds to a single processor * this bit unbinds children which will then bind to another cpu /* Disable the parent's signal handlers and set up proper handling in /* The child process doesn't do anything for AP_SIG_GRACEFUL. * Instead, the pod is used for signalling graceful restart. /* start up a bunch of children */ * 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. /* initialize the free_list */ /* try to keep children numbers as low as possible */ /* 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. /* always kill the highest numbered child if we have to... * no really well thought out reason ... other than observing * the server behaviour under linux where lower numbered children * tend to service more hits (and hence are more likely to have * their data in cpu caches). /* kill off one child... we use the pod because that'll cause it to * shut down gracefully, in case it happened to pick up a request /* terminate the free list */ /* only report this condition once */ "server reached MaxClients setting, consider" " raising the MaxClients setting");
"server seems busy, (you may need " "spawning %d children, there are %d idle, and " "No active child processes: shutting down");
/* 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 /***************************************************************** "WARNING: Attempt to change ServerLimit " "ignored during restart");
/* Initialize cross-process accept lock */ "Couldn't create accept lock");
"Couldn't set permissions on cross-process lock");
/* fix the generation number in the global score; we just got a new, /* 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. /* give the system some time to recover before kicking into "%s configured -- resuming normal operations",
/* this is a memory leak, but I'll fix it later. */ /* XXX: if it takes longer than 1 second for all our children * to start up and get into IDLE state then we may spawn an /* non-fatal death... note that it's gone in the scoreboard. */ /* child detected a resource shortage (E[NM]FILE, ENOBUFS, etc) * cut the fork rate to the minimum /* we're still doing a 1-for-1 replacement of dead * children with new children /* Great, we've probably just lost a slot in the * scoreboard. Somehow we don't know about this "long lost child came home! (pid %ld)", (
long)
pid.
pid);
/* 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. /* 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. /* Time to gracefully shut down: * Kill child processes, tell them to call child_exit, etc... /* cleanup pid file on normal shutdown */ "removed PID file %s (pid=%ld)",
"caught SIGTERM, shutting down");
/* we've been told to restart */ /* not worth thinking about */ /* 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. "Graceful restart requested, doing restart");
/* kill off the idle ones */ /* This is mostly for debugging... so that we know what is still * gracefully dealing with existing request. But we can't really * do it if we're in a SCOREBOARD_FILE because it'll cause "SIGHUP received. Attempting to restart");
/* 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. NULL,
"no listening sockets available, shutting down");
"Could not open pipe-of-death.");
/* sigh, want this only the second time around */ "apr_proc_detach failed");
/* The prefork open_logs phase must run before the core's, or stderr * will be redirected to a file, and the messages won't print to the "WARNING: detected MinSpareServers set to non-positive.");
"Resetting to 1 to avoid almost certain Apache failure.");
"Please read the documentation.");
"WARNING: MaxClients of %d exceeds ServerLimit value " " lowering MaxClients to %d. To increase, please " "WARNING: Require MaxClients > 0, setting to 1");
/* you cannot change ServerLimit across a restart; ignore /* 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() "WARNING: ServerLimit of %d exceeds compile time limit " "WARNING: Require ServerLimit > 0, setting to 1");
"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"),
"Maximum value of MaxClients for this run of Apache"),
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 */