www/apache
1
0
Fork 0
mirror of https://github.com/apache/httpd.git synced 2026-10-23 22:49:01 +03:00
Code Activity
Files
cache-refactor
apache/docs/manual/mod/worker.xml
Chris Darroch e69f467709 Introduce a check_config phase between pre_config and open_logs, 
to allow modules to review interdependent configuration directive
values and adjust them while messages can still be logged to the
console.

The open_logs phase is already used somewhat for this purpose by
certain MPMs (winnt, prefork, worker, and event) but only by forcing
their functions ahead of the core ap_open_logs() function, and
since this phase runs after the ap_signal_server function during startup,
it can not be used to generate messages on the console when restarting.

Add the check_config phase to mod_info and mod_example.

Handle relevant MPM directives during this phase and format messages
for both the console and the error log, as appropriate.  Bounds and sanity
checks on the values of the MPM directives are handled in sequence in
this phase instead of in the various directive handling functions, since
those functions (e.g., set_max_clients()) may not be called at all if their
directives do not appear in the configuration files, and even if they
are called, there is no guarantee that this will occur in any particular
order.

Remove from the worker and event MPMs the code in the pre_config phase
that alters the configuration node tree by re-ordering ThreadsPerChild
ahead of MaxClients.  This code is effective but insufficient; for
example, if ServerLimit follows MaxClients, the test against server_limit
in set_max_clients() is invalid.  (In practice, this only results in
incorrect or absent warnings on the console, because server_limit is
set to its configured value when the main loop re-runs the configuration
process.)

Prevent ap_threads_per_child from exceeding thread_limit in the
winnt, worker, and event MPMs.  This situation could occur if
ThreadsPerChild was not specified in the configuration files and
ThreadLimit was set to a value smaller than DEFAULT_THREADS_PER_CHILD,
because set_threads_per_child() would never be called and therefore
its bounds check against thread_limit would not be performed.

Remove from the winnt, prefork, worker, and event MPMs the
changed_limit_at_restart flag.  Set the first_server_limit and
first_thread_limit values during the first execution of the check_config
function, and use them to detect changes to ServerLimit and ThreadLimit
across restarts and issue appropriately formatted warnings.  Remove the
comments about the error log being a "bit bucket"; this was true when
the code was originally committed in r92530 but that was due to a bug
fixed in r92769.

Be consistent about setting all MPM configuration directive values in the
pre_config phase.

Rephrase and reformat the console and log file messages relating to
MPM configuration directives to be consistent across all MPMs.  Use
briefer messages when logging to the error log than to the console.

Update miscellaneous stale comments and messages (e.g., reference to
daemons_min_free in worker and event MPMs, "prefork open_logs" in
winnt MPM, and StartServers in netware MPM).

The winnt, netware, beos, and mpmt_os2 MPMs should be tested by developers
with access to those platforms, especially the winnt MPM, which has
unique logic with respect to distinguishing between parent and child
processes during the configuration phases.

Update the English documentation for the worker MPM's ThreadsPerChild
directive, which no longer needs to precede other MPM directives in the
configuration files if it has a non-default value.  The German (.de) and
Japanese (.ja) translations should be updated by developers fluent in
those languages.



git-svn-id: https://svn.apache.org/repos/asf/httpd/httpd/trunk@431460 13f79535-47bb-0310-9956-ffa450edef68
2006-08-14 22:55:45 +00:00

186 lines
8.5 KiB
XML
Raw Permalink Blame History

<?xml version="1.0"?>
<!DOCTYPE modulesynopsis SYSTEM "../style/modulesynopsis.dtd">
<?xml-stylesheet type="text/xsl" href="../style/manual.en.xsl"?>
<!-- $LastChangedRevision$ -->
<!--
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
http://www.apache.org/licenses/LICENSE-2.0
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.
-->
<modulesynopsis metafile="worker.xml.meta">
<name>worker</name>
<description>Multi-Processing Module implementing a hybrid
multi-threaded multi-process web server</description>
<status>MPM</status>
<sourcefile>worker.c</sourcefile>
<identifier>mpm_worker_module</identifier>
<summary>
<p>This Multi-Processing Module (MPM) implements a hybrid
multi-process multi-threaded server. By using threads to serve
requests, it is able to serve a large number of requests with
fewer system resources than a process-based server. However, it
retains much of the stability of a process-based server by
keeping multiple processes available, each with many threads.</p>
<p>The most important directives used to control this MPM are
<directive module="mpm_common">ThreadsPerChild</directive>, which
controls the number of threads deployed by each child process and
<directive module="mpm_common">MaxClients</directive>, which
controls the maximum total number of threads that may be
launched.</p>
</summary>
<seealso><a href="../bind.html">Setting which addresses and ports Apache
uses</a></seealso>
<section id="how-it-works"><title>How it Works</title>
<p>A single control process (the parent) is responsible for launching
child processes. Each child process creates a fixed number of server
threads as specified in the <directive
module="mpm_common">ThreadsPerChild</directive> directive, as well
as a listener thread which listens for connections and passes them
to a server thread for processing when they arrive.</p>
<p>Apache always tries to maintain a pool of <dfn>spare</dfn> or
idle server threads, which stand ready to serve incoming
requests. In this way, clients do not need to wait for a new
threads or processes to be created before their requests can be
served. The number of processes that will initially launched is
set by the <directive module="mpm_common">StartServers</directive>
directive. During operation, Apache assesses the total number
of idle threads in all processes, and forks or kills processes to
keep this number within the boundaries specified by <directive
module="mpm_common">MinSpareThreads</directive> and <directive
module="mpm_common">MaxSpareThreads</directive>. Since this
process is very self-regulating, it is rarely necessary to modify
these directives from their default values. The maximum number of
clients that may be served simultaneously (i.e., the maximum total
number of threads in all processes) is determined by the
<directive module="mpm_common">MaxClients</directive> directive.
The maximum number of active child processes is determined by
the <directive module="mpm_common">MaxClients</directive>
directive divided by the <directive module="mpm_common">
ThreadsPerChild</directive> directive.</p>
<p>Two directives set hard limits on the number of active child
processes and the number of server threads in a child process,
and can only be changed by fully stopping the server and then
starting it again. <directive module="mpm_common">ServerLimit
</directive> is a hard limit on the number of active child
processes, and must be greater than or equal to the
<directive module="mpm_common">MaxClients</directive>
directive divided by the <directive module="mpm_common">
ThreadsPerChild</directive> directive.
<directive module="mpm_common">ThreadLimit</directive> is a hard
limit of the number of server threads, and must be greater than
or equal to the <directive
module="mpm_common">ThreadsPerChild</directive> directive.</p>
<p>In addition to the set of active child processes, there may
be additional child processes which are terminating, but where at
least one server thread is still handling an existing client
connection. Up to <directive
module="mpm_common">MaxClients</directive> terminating processes
may be present, though the actual number can be expected to be
much smaller. This behavior can be avoided by disabling the
termination of individual child processes, which is achieved using
the following:</p>
<ul>
<li>set the value of <directive module="mpm_common">
MaxRequestsPerChild</directive> to zero</li>
<li>set the value of <directive module="mpm_common">
MaxSpareThreads</directive> to the same value as
<directive module="mpm_common">MaxClients</directive></li>
</ul>
<p>A typical configuration of the process-thread controls in
the <module>worker</module> MPM could look as follows:</p>
<example>
ServerLimit 16<br />
StartServers 2<br />
MaxClients 150<br />
MinSpareThreads 25<br />
MaxSpareThreads 75<br />
ThreadsPerChild 25
</example>
<p>While the parent process is usually started as <code>root</code>
under Unix in order to bind to port 80, the child processes and threads
are launched by Apache as a less-privileged user. The <directive
module="mpm_common">User</directive> and <directive
module="mpm_common">Group</directive> directives are used to set
the privileges of the Apache child processes. The child processes
must be able to read all the content that will be served, but
should have as few privileges beyond that as possible. In
addition, unless <program>suexec</program> is used,
these directives also set the privileges which will be inherited
by CGI scripts.</p>
<p><directive module="mpm_common">MaxRequestsPerChild</directive>
controls how frequently the server recycles processes by killing
old ones and launching new ones.</p>
</section>
<directivesynopsis location="mpm_common"><name>AcceptMutex</name>
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>CoreDumpDirectory</name>
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>EnableExceptionHook</name>
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>Group</name>
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>PidFile</name>
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>Listen</name>
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>ListenBacklog</name>
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>LockFile</name>
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>MaxClients</name>
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>MaxMemFree</name>
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>MaxRequestsPerChild</name>
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>MaxSpareThreads</name>
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>MinSpareThreads</name>
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>ScoreBoardFile</name>
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>ReceiveBufferSize</name>
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>SendBufferSize</name>
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>ServerLimit</name>
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>StartServers</name>
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>ThreadLimit</name>
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>ThreadsPerChild</name>
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>ThreadStackSize</name>
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>User</name>
</directivesynopsis>
</modulesynopsis>
View Git Blame Copy Permalink