Changes with Apache 2.3.13
+ *) prefork, worker, event: Rename MaxClients to MaxRequestWorkers which
+ describes more accurately what it does. [Stefan Fritsch]
+
*) rotatelogs: Add -p argument to specify custom program to invoke
after a log rotation. PR 51285. [<sveniu ifi.uio.no>, Joe Orton]
# StartServers: number of server processes to start
# MinSpareServers: minimum number of server processes which are kept spare
# MaxSpareServers: maximum number of server processes which are kept spare
-# MaxClients: maximum number of server processes allowed to start
+# MaxRequestWorkers: maximum number of server processes allowed to start
# MaxConnectionsPerChild: maximum number of connections a server process serves
# before terminating
<IfModule mpm_prefork_module>
StartServers 5
MinSpareServers 5
MaxSpareServers 10
- MaxClients 150
+ MaxRequestWorkers 150
MaxConnectionsPerChild 0
</IfModule>
# worker MPM
# StartServers: initial number of server processes to start
-# MaxClients: maximum number of simultaneous client connections
# MinSpareThreads: minimum number of worker threads which are kept spare
# MaxSpareThreads: maximum number of worker threads which are kept spare
# ThreadsPerChild: constant number of worker threads in each server process
+# MaxRequestWorkers: maximum number of worker threads
# MaxConnectionsPerChild: maximum number of connections a server process serves
# before terminating
<IfModule mpm_worker_module>
StartServers 2
- MaxClients 150
MinSpareThreads 25
MaxSpareThreads 75
ThreadsPerChild 25
+ MaxRequestWorkers 150
MaxConnectionsPerChild 0
</IfModule>
# event MPM
# StartServers: initial number of server processes to start
-# MaxClients: maximum number of simultaneous client connections
# MinSpareThreads: minimum number of worker threads which are kept spare
# MaxSpareThreads: maximum number of worker threads which are kept spare
# ThreadsPerChild: constant number of worker threads in each server process
+# MaxRequestWorkers: maximum number of worker threads
# MaxConnectionsPerChild: maximum number of connections a server process serves
# before terminating
<IfModule mpm_event_module>
StartServers 2
- MaxClients 150
MinSpareThreads 25
MaxSpareThreads 75
ThreadsPerChild 25
+ MaxRequestWorkers 150
MaxConnectionsPerChild 0
</IfModule>
that users consider "fast enough". This causes users to hit
stop and reload, further increasing the load. You can, and
should, control the <directive module="mpm_common"
- >MaxClients</directive> setting so that your server
+ >MaxRequestWorkers</directive> setting so that your server
does not spawn so many children it starts swapping. This procedure
for doing this is simple: determine the size of your average Apache
process, by looking at your process list via a tool such as
require reconfiguration of your kernel.</li>
<li>Tune the <directive
- module="mpm_common">MaxClients</directive> directive to allow
+ module="mpm_common">MaxRequestWorkers</directive> directive to allow
the server to handle the maximum number of simultaneous
connections without running out of resources. See also the <a
href="perf-tuning.html">performance tuning
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>SendBufferSize</name>
</directivesynopsis>
-<directivesynopsis location="mpm_common"><name>MaxClients</name>
+<directivesynopsis location="mpm_common"><name>MaxRequestWorkers</name>
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>MaxMemFree</name>
</directivesynopsis>
</directivesynopsis>
<directivesynopsis>
-<name>MaxClients</name>
+<name>MaxRequestWorkers</name>
<description>Maximum number of connections that will be processed
simultaneously</description>
-<syntax>MaxClients <var>number</var></syntax>
+<syntax>MaxRequestWorkers <var>number</var></syntax>
<default>See usage for details</default>
<contextlist><context>server config</context></contextlist>
<modulelist><module>event</module><module>prefork</module>
</modulelist>
<usage>
- <p>The <directive>MaxClients</directive> directive sets the limit
+ <p>The <directive>MaxRequestWorkers</directive> directive sets the limit
on the number of simultaneous requests that will be served. Any
- connection attempts over the <directive>MaxClients</directive>
+ connection attempts over the <directive>MaxRequestWorkers</directive>
limit will normally be queued, up to a number based on the
<directive module="mpm_common">ListenBacklog</directive>
directive. Once a child process is freed at the end of a different
request, the connection will then be serviced.</p>
<p>For non-threaded servers (<em>i.e.</em>, <module>prefork</module>),
- <directive>MaxClients</directive> translates into the maximum
+ <directive>MaxRequestWorkers</directive> translates into the maximum
number of child processes that will be launched to serve requests.
The default value is <code>256</code>; to increase it, you must also raise
<directive module="mpm_common">ServerLimit</directive>.</p>
<p>For threaded and hybrid servers (<em>e.g.</em> <module>event</module>
- or <module>worker</module>) <directive>MaxClients</directive> restricts
+ or <module>worker</module>) <directive>MaxRequestWorkers</directive> restricts
the total number of threads that will be available to serve clients.
For hybrid MPMs the default value is <code>16</code> (<directive
module="mpm_common">ServerLimit</directive>) multiplied by the value of
<code>25</code> (<directive module="mpm_common"
>ThreadsPerChild</directive>). Therefore, to increase <directive
- >MaxClients</directive> to a value that requires more than 16 processes,
+ >MaxRequestWorkers</directive> to a value that requires more than 16 processes,
you must also raise <directive module="mpm_common"
>ServerLimit</directive>.</p>
+
+ <p><directive>MaxRequestWorkers</directive> was called
+ <directive>MaxClients</directive> before version 2.3.13. The old name ist still
+ supported.</p>
</usage>
</directivesynopsis>
<usage>
<p>For the <module>prefork</module> MPM, this directive sets the
maximum configured value for <directive
- module="mpm_common">MaxClients</directive> for the lifetime of the
+ module="mpm_common">MaxRequestWorkers</directive> for the lifetime of the
Apache httpd process. For the <module>worker</module> MPM, this directive
in combination with <directive
module="mpm_common">ThreadLimit</directive> sets
the maximum configured value for <directive
- module="mpm_common">MaxClients</directive> for the lifetime of the
+ module="mpm_common">MaxRequestWorkers</directive> for the lifetime of the
Apache httpd process. Any attempts to change this directive during a
restart will be ignored, but <directive
- module="mpm_common">MaxClients</directive> can be modified during
+ module="mpm_common">MaxRequestWorkers</directive> can be modified during
a restart.</p>
<p>Special care must be taken when using this directive. If
<directive>ServerLimit</directive> is set to a value much higher
than necessary, extra, unused shared memory will be allocated. If
both <directive>ServerLimit</directive> and <directive
- module="mpm_common">MaxClients</directive> are set to values
+ module="mpm_common">MaxRequestWorkers</directive> are set to values
higher than the system can handle, Apache httpd may not start or the
system may become unstable.</p>
<p>With the <module>prefork</module> MPM, use this directive only
if you need to set <directive
- module="mpm_common">MaxClients</directive> higher than 256 (default).
+ module="mpm_common">MaxRequestWorkers</directive> higher than 256 (default).
Do not set the value of this directive any higher than what you
might want to set <directive
- module="mpm_common">MaxClients</directive> to.</p>
+ module="mpm_common">MaxRequestWorkers</directive> to.</p>
<p>With <module>worker</module>, use this directive only
- if your <directive module="mpm_common">MaxClients</directive> and
+ if your <directive module="mpm_common">MaxRequestWorkers</directive> and
<directive module="mpm_common">ThreadsPerChild</directive>
settings require more than 16 server processes (default). Do not set
the value of this directive any higher than the number of server
processes required by what you may want for <directive
- module="mpm_common">MaxClients </directive> and <directive
+ module="mpm_common">MaxRequestWorkers </directive> and <directive
module="mpm_common">ThreadsPerChild</directive>.</p>
<note><title>Note</title>
<p>This MPM is very self-regulating, so it is rarely necessary to
adjust its configuration directives. Most important is that
- <directive module="mpm_common">MaxClients</directive> be big enough to
- handle as many simultaneous requests as you expect to receive, but
+ <directive module="mpm_common">MaxRequestWorkers</directive> be big enough
+ to handle as many simultaneous requests as you expect to receive, but
small enough to assure that there is enough physical RAM for all
processes.</p>
</summary>
<p>The <directive module="mpm_common">StartServers</directive>,
<directive module="prefork">MinSpareServers</directive>,
<directive module="prefork">MaxSpareServers</directive>, and
- <directive module="mpm_common">MaxClients</directive> regulate how
+ <directive module="mpm_common">MaxRequestWorkers</directive> regulate how
the parent process creates children to serve requests. In general,
Apache httpd is very self-regulating, so most sites do not need to
adjust these directives from their default values. Sites which
need to serve more than 256 simultaneous requests may need to
- increase <directive module="mpm_common">MaxClients</directive>,
+ increase <directive module="mpm_common">MaxRequestWorkers</directive>,
while sites with limited memory may need to decrease <directive
- module="mpm_common">MaxClients</directive> to keep the server from
+ module="mpm_common">MaxRequestWorkers</directive> to keep the server from
thrashing (swapping memory to disk and back). More information
about tuning process creation is provided in the <a
href="../misc/perf-tuning.html">performance hints</a>
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>ListenBacklog</name>
</directivesynopsis>
-<directivesynopsis location="mpm_common"><name>MaxClients</name>
+<directivesynopsis location="mpm_common"><name>MaxRequestWorkers</name>
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>MaxMemFree</name>
</directivesynopsis>
<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
+ <directive module="mpm_common">MaxRequestWorkers</directive>, which
controls the maximum total number of threads that may be
launched.</p>
</summary>
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.
+ <directive module="mpm_common">MaxRequestWorkers</directive> directive.
The maximum number of active child processes is determined by
- the <directive module="mpm_common">MaxClients</directive>
+ the <directive module="mpm_common">MaxRequestWorkers</directive>
directive divided by the <directive module="mpm_common">
ThreadsPerChild</directive> directive.</p>
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 module="mpm_common">MaxRequestWorkers</directive>
directive divided by the <directive module="mpm_common">
ThreadsPerChild</directive> directive.
<directive module="mpm_common">ThreadLimit</directive> is a hard
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
+ module="mpm_common">MaxRequestWorkers</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
<li>set the value of <directive module="mpm_common">
MaxSpareThreads</directive> to the same value as
- <directive module="mpm_common">MaxClients</directive></li>
+ <directive module="mpm_common">MaxRequestWorkers</directive></li>
</ul>
<p>A typical configuration of the process-thread controls in
<example>
ServerLimit 16<br />
StartServers 2<br />
- MaxClients 150<br />
+ MaxRequestWorkers 150<br />
MinSpareThreads 25<br />
MaxSpareThreads 75<br />
ThreadsPerChild 25
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>ListenBacklog</name>
</directivesynopsis>
-<directivesynopsis location="mpm_common"><name>MaxClients</name>
+<directivesynopsis location="mpm_common"><name>MaxRequestWorkers</name>
</directivesynopsis>
<directivesynopsis location="mpm_common"><name>MaxMemFree</name>
</directivesynopsis>
<ul>
<li><directive>MaxRequestsPerChild</directive> has been renamed to
<directive module="mpm_common">MaxConnectionsPerChild</directive>,
- which describes more accurately what it does.</li>
+ describes more accurately what it does. The old name is still
+ supported.</li>
+
+ <li><directive>MaxClients</directive> has been renamed to
+ <directive module="mpm_common">MaxRequestWorkers</directive>,
+ which describes more accurately what it does. For async MPMs, like
+ <module>event</module>, the maximum number of clients is not
+ equivalent than the number of worker threads. The old name is still
+ supported.</li>
<li>The <directive module="core">DefaultType</directive>
directive no longer has any effect, other than to emit a
{STAT_OPT_END, NULL, NULL}
};
-/* add another state for slots above the MaxClients setting */
+/* add another state for slots above the MaxRequestWorkers setting */
#define SERVER_DISABLED SERVER_NUM_STATUS
#define MOD_STATUS_NUM_STATUS (SERVER_NUM_STATUS+1)
static int min_spare_threads = 0;
static int max_spare_threads = 0;
static int ap_daemons_limit = 0;
-static int max_clients = 0;
+static int max_workers = 0;
static int server_limit = 0;
static int thread_limit = 0;
static int dying = 0;
int maxclients_reported;
/*
* 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
+ * 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;
if (active_thread_count >= ap_daemons_limit * threads_per_child) {
if (!retained->maxclients_reported) {
/* only report this condition once */
- ap_log_error(APLOG_MARK, APLOG_ERR, 0,
- ap_server_conf,
- "server reached MaxClients setting, consider"
- " raising the MaxClients setting");
+ ap_log_error(APLOG_MARK, APLOG_ERR, 0, ap_server_conf,
+ "server reached MaxRequestWorkers setting, "
+ "consider raising the MaxRequestWorkers "
+ "setting");
retained->maxclients_reported = 1;
}
}
else {
- ap_log_error(APLOG_MARK, APLOG_ERR, 0,
- ap_server_conf,
- "scoreboard is full, not at MaxClients");
+ ap_log_error(APLOG_MARK, APLOG_ERR, 0, ap_server_conf,
+ "scoreboard is full, not at MaxRequestWorkers");
}
retained->idle_spawn_rate = 1;
}
free_length = retained->idle_spawn_rate;
}
if (retained->idle_spawn_rate >= 8) {
- ap_log_error(APLOG_MARK, APLOG_INFO, 0,
- ap_server_conf,
+ ap_log_error(APLOG_MARK, APLOG_INFO, 0, ap_server_conf,
"server seems busy, (you may need "
"to increase StartServers, ThreadsPerChild "
"or Min/MaxSpareThreads), "
thread_limit = DEFAULT_THREAD_LIMIT;
ap_daemons_limit = server_limit;
threads_per_child = DEFAULT_THREADS_PER_CHILD;
- max_clients = ap_daemons_limit * threads_per_child;
+ max_workers = ap_daemons_limit * threads_per_child;
ap_extended_status = 0;
return OK;
threads_per_child = 1;
}
- if (max_clients < threads_per_child) {
+ if (max_workers < threads_per_child) {
if (startup) {
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
- "WARNING: MaxClients of %d is less than "
- "ThreadsPerChild of", max_clients);
+ "WARNING: MaxRequestWorkers of %d is less than "
+ "ThreadsPerChild of", max_workers);
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
- " %d, increasing to %d. MaxClients must be at "
+ " %d, increasing to %d. MaxRequestWorkers must be at "
"least as large",
threads_per_child, threads_per_child);
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
" as the number of threads in a single server.");
} else {
ap_log_error(APLOG_MARK, APLOG_WARNING, 0, s,
- "MaxClients of %d is less than ThreadsPerChild "
+ "MaxRequestWorkers of %d is less than ThreadsPerChild "
"of %d, increasing to match",
- max_clients, threads_per_child);
+ max_workers, threads_per_child);
}
- max_clients = threads_per_child;
+ max_workers = threads_per_child;
}
- ap_daemons_limit = max_clients / threads_per_child;
+ ap_daemons_limit = max_workers / threads_per_child;
- if (max_clients % threads_per_child) {
- int tmp_max_clients = ap_daemons_limit * threads_per_child;
+ if (max_workers % threads_per_child) {
+ int tmp_max_workers = ap_daemons_limit * threads_per_child;
if (startup) {
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
- "WARNING: MaxClients of %d is not an integer "
- "multiple of", max_clients);
+ "WARNING: MaxRequestWorkers of %d is not an integer "
+ "multiple of", max_workers);
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
" ThreadsPerChild of %d, decreasing to nearest "
"multiple %d,", threads_per_child,
- tmp_max_clients);
+ tmp_max_workers);
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
" for a maximum of %d servers.",
ap_daemons_limit);
} else {
ap_log_error(APLOG_MARK, APLOG_WARNING, 0, s,
- "MaxClients of %d is not an integer multiple of "
- "ThreadsPerChild of %d, decreasing to nearest "
- "multiple %d", max_clients, threads_per_child,
- tmp_max_clients);
+ "MaxRequestWorkers of %d is not an integer multiple "
+ "of ThreadsPerChild of %d, decreasing to nearest "
+ "multiple %d", max_workers, threads_per_child,
+ tmp_max_workers);
}
- max_clients = tmp_max_clients;
+ max_workers = tmp_max_workers;
}
if (ap_daemons_limit > server_limit) {
if (startup) {
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
- "WARNING: MaxClients of %d would require %d "
- "servers and ", max_clients, ap_daemons_limit);
+ "WARNING: MaxRequestWorkers of %d would require %d "
+ "servers and ", max_workers, ap_daemons_limit);
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
" would exceed ServerLimit of %d, decreasing to %d.",
server_limit, server_limit * threads_per_child);
"directive.");
} else {
ap_log_error(APLOG_MARK, APLOG_WARNING, 0, s,
- "MaxClients of %d would require %d servers and "
+ "MaxRequestWorkers of %d would require %d servers and "
"exceed ServerLimit of %d, decreasing to %d",
- max_clients, ap_daemons_limit, server_limit,
+ max_workers, ap_daemons_limit, server_limit,
server_limit * threads_per_child);
}
ap_daemons_limit = server_limit;
return NULL;
}
-static const char *set_max_clients(cmd_parms * cmd, void *dummy,
+static const char *set_max_workers(cmd_parms * cmd, void *dummy,
const char *arg)
{
const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
if (err != NULL) {
return err;
}
-
- max_clients = atoi(arg);
+ if (!strcasecmp(cmd->cmd->name, "MaxRequestWorkers")) {
+ ap_log_error(APLOG_MARK, APLOG_WARNING, 0, NULL,
+ "MaxClients is deprecated, use MaxRequestWorkers "
+ "instead.");
+ }
+ max_workers = atoi(arg);
return NULL;
}
"Minimum number of idle threads, to handle request spikes"),
AP_INIT_TAKE1("MaxSpareThreads", set_max_spare_threads, NULL, RSRC_CONF,
"Maximum number of idle threads"),
- AP_INIT_TAKE1("MaxClients", set_max_clients, NULL, RSRC_CONF,
+ AP_INIT_TAKE1("MaxClients", set_max_workers, NULL, RSRC_CONF,
+ "Deprecated name of MaxRequestWorkers"),
+ AP_INIT_TAKE1("MaxRequestWorkers", set_max_workers, NULL, RSRC_CONF,
"Maximum number of threads alive at the same time"),
AP_INIT_TAKE1("ThreadsPerChild", set_threads_per_child, NULL, RSRC_CONF,
"Number of threads each child creates"),
/*
Todo list
- - Enforce MaxClients somehow
+ - Enforce MaxRequestWorkers somehow
*/
#define INCL_NOPMAPI
#define INCL_DOS
/*
* The max child slot ever assigned, preserved across restarts. Necessary
- * to deal with MaxClients changes across SIGWINCH restarts. We use this
+ * to deal with MaxRequestWorkers changes across SIGWINCH restarts. We use this
* value to optimize routines that have to scan the entire scoreboard.
*/
static int ap_max_workers_limit = -1;
if (!reported) {
ap_log_error(APLOG_MARK, APLOG_ERR, 0, ap_server_conf,
- "server reached MaxClients setting, consider"
- " raising the MaxClients setting");
+ "server reached MaxRequestWorkers setting, consider"
+ " raising the MaxRequestWorkers setting");
reported = 1;
}
idle_spawn_rate = 1;
static int ap_daemons_to_start=0;
static int ap_daemons_min_free=0;
static int ap_daemons_max_free=0;
-static int ap_daemons_limit=0; /* MaxClients */
+static int ap_daemons_limit=0; /* MaxRequestWorkers */
static int server_limit = 0;
static int mpm_state = AP_MPMQ_STARTING;
static ap_pod_t *pod;
int maxclients_reported;
/*
* The max child slot ever assigned, preserved across restarts. Necessary
- * to deal with MaxClients changes across AP_SIG_GRACEFUL restarts. We
+ * 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;
/* only report this condition once */
if (!retained->maxclients_reported) {
ap_log_error(APLOG_MARK, APLOG_ERR, 0, ap_server_conf,
- "server reached MaxClients setting, consider"
- " raising the MaxClients setting");
+ "server reached MaxRequestWorkers setting, consider"
+ " raising the MaxRequestWorkers setting");
retained->maxclients_reported = 1;
}
retained->idle_spawn_rate = 1;
if (ap_daemons_limit > server_limit) {
if (startup) {
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
- "WARNING: MaxClients of %d exceeds ServerLimit "
+ "WARNING: MaxRequestWorkers of %d exceeds ServerLimit "
"value of", ap_daemons_limit);
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
- " %d servers, decreasing MaxClients to %d.",
+ " %d servers, decreasing MaxRequestWorkers to %d.",
server_limit, server_limit);
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
" To increase, please see the ServerLimit "
"directive.");
} else {
ap_log_error(APLOG_MARK, APLOG_WARNING, 0, s,
- "MaxClients of %d exceeds ServerLimit value "
+ "MaxRequestWorkers of %d exceeds ServerLimit value "
"of %d, decreasing to match",
ap_daemons_limit, server_limit);
}
else if (ap_daemons_limit < 1) {
if (startup) {
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
- "WARNING: MaxClients of %d not allowed, "
+ "WARNING: MaxRequestWorkers of %d not allowed, "
"increasing to 1.", ap_daemons_limit);
} else {
ap_log_error(APLOG_MARK, APLOG_WARNING, 0, s,
- "MaxClients of %d not allowed, increasing to 1",
+ "MaxRequestWorkers of %d not allowed, increasing to 1",
ap_daemons_limit);
}
ap_daemons_limit = 1;
if (err != NULL) {
return err;
}
-
+ if (!strcasecmp(cmd->cmd->name, "MaxRequestWorkers")) {
+ ap_log_error(APLOG_MARK, APLOG_WARNING, 0, NULL,
+ "MaxClients is deprecated, use MaxRequestWorkers "
+ "instead.");
+ }
ap_daemons_limit = atoi(arg);
return NULL;
}
AP_INIT_TAKE1("MaxSpareServers", set_max_free_servers, NULL, RSRC_CONF,
"Maximum number of idle children"),
AP_INIT_TAKE1("MaxClients", set_max_clients, NULL, RSRC_CONF,
+ "Deprecated name of MaxRequestWorkers"),
+AP_INIT_TAKE1("MaxRequestWorkers", set_max_clients, NULL, RSRC_CONF,
"Maximum number of children alive at the same time"),
AP_INIT_TAKE1("ServerLimit", set_server_limit, NULL, RSRC_CONF,
- "Maximum value of MaxClients for this run of Apache"),
+ "Maximum value of MaxRequestWorkers for this run of Apache"),
AP_GRACEFUL_SHUTDOWN_TIMEOUT_COMMAND,
{ NULL }
};
static int min_spare_threads = 0;
static int max_spare_threads = 0;
static int ap_daemons_limit = 0;
-static int max_clients = 0;
+static int max_workers = 0;
static int server_limit = 0;
static int thread_limit = 0;
static int dying = 0;
int near_maxclients_reported;
/*
* 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
+ * 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;
if (active_thread_count >= ap_daemons_limit * threads_per_child) {
/* no threads are "inactive" - starting, stopping, etc. */
- /* have we reached MaxClients, or just getting close? */
+ /* have we reached MaxRequestWorkers, or just getting close? */
if (0 == idle_thread_count) {
if (!retained->maxclients_reported) {
/* only report this condition once */
- ap_log_error(APLOG_MARK, APLOG_ERR, 0,
- ap_server_conf,
- "server reached MaxClients setting, consider"
- " raising the MaxClients setting");
+ ap_log_error(APLOG_MARK, APLOG_ERR, 0, ap_server_conf,
+ "server reached MaxRequestWorkers "
+ "setting, consider raising the "
+ "MaxRequestWorkers setting");
retained->maxclients_reported = 1;
}
} else {
if (!retained->near_maxclients_reported) {
- ap_log_error(APLOG_MARK, APLOG_ERR, 0,
- ap_server_conf,
- "server is within MinSpareThreads of MaxClients, "
- "consider raising the MaxClients setting");
+ ap_log_error(APLOG_MARK, APLOG_ERR, 0, ap_server_conf,
+ "server is within MinSpareThreads of "
+ "MaxRequestWorkers, consider raising the "
+ "MaxRequestWorkers setting");
retained->near_maxclients_reported = 1;
}
}
else {
ap_log_error(APLOG_MARK, APLOG_ERR, 0,
ap_server_conf,
- "scoreboard is full, not at MaxClients");
+ "scoreboard is full, not at MaxRequestWorkers");
}
retained->idle_spawn_rate = 1;
}
thread_limit = DEFAULT_THREAD_LIMIT;
ap_daemons_limit = server_limit;
threads_per_child = DEFAULT_THREADS_PER_CHILD;
- max_clients = ap_daemons_limit * threads_per_child;
+ max_workers = ap_daemons_limit * threads_per_child;
ap_extended_status = 0;
return OK;
threads_per_child = 1;
}
- if (max_clients < threads_per_child) {
+ if (max_workers < threads_per_child) {
if (startup) {
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
- "WARNING: MaxClients of %d is less than "
- "ThreadsPerChild of", max_clients);
+ "WARNING: MaxRequestWorkers of %d is less than "
+ "ThreadsPerChild of", max_workers);
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
- " %d, increasing to %d. MaxClients must be at "
+ " %d, increasing to %d. MaxRequestWorkers must be at "
"least as large",
threads_per_child, threads_per_child);
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
" as the number of threads in a single server.");
} else {
ap_log_error(APLOG_MARK, APLOG_WARNING, 0, s,
- "MaxClients of %d is less than ThreadsPerChild "
+ "MaxRequestWorkers of %d is less than ThreadsPerChild "
"of %d, increasing to match",
- max_clients, threads_per_child);
+ max_workers, threads_per_child);
}
- max_clients = threads_per_child;
+ max_workers = threads_per_child;
}
- ap_daemons_limit = max_clients / threads_per_child;
+ ap_daemons_limit = max_workers / threads_per_child;
- if (max_clients % threads_per_child) {
- int tmp_max_clients = ap_daemons_limit * threads_per_child;
+ if (max_workers % threads_per_child) {
+ int tmp_max_workers = ap_daemons_limit * threads_per_child;
if (startup) {
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
- "WARNING: MaxClients of %d is not an integer "
- "multiple of", max_clients);
+ "WARNING: MaxRequestWorkers of %d is not an integer "
+ "multiple of", max_workers);
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
" ThreadsPerChild of %d, decreasing to nearest "
"multiple %d,", threads_per_child,
- tmp_max_clients);
+ tmp_max_workers);
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
" for a maximum of %d servers.",
ap_daemons_limit);
} else {
ap_log_error(APLOG_MARK, APLOG_WARNING, 0, s,
- "MaxClients of %d is not an integer multiple of "
+ "MaxRequestWorkers of %d is not an integer multiple of "
"ThreadsPerChild of %d, decreasing to nearest "
- "multiple %d", max_clients, threads_per_child,
- tmp_max_clients);
+ "multiple %d", max_workers, threads_per_child,
+ tmp_max_workers);
}
- max_clients = tmp_max_clients;
+ max_workers = tmp_max_workers;
}
if (ap_daemons_limit > server_limit) {
if (startup) {
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
- "WARNING: MaxClients of %d would require %d "
- "servers and ", max_clients, ap_daemons_limit);
+ "WARNING: MaxRequestWorkers of %d would require %d "
+ "servers and ", max_workers, ap_daemons_limit);
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
" would exceed ServerLimit of %d, decreasing to %d.",
server_limit, server_limit * threads_per_child);
"directive.");
} else {
ap_log_error(APLOG_MARK, APLOG_WARNING, 0, s,
- "MaxClients of %d would require %d servers and "
+ "MaxRequestWorkers of %d would require %d servers and "
"exceed ServerLimit of %d, decreasing to %d",
- max_clients, ap_daemons_limit, server_limit,
+ max_workers, ap_daemons_limit, server_limit,
server_limit * threads_per_child);
}
ap_daemons_limit = server_limit;
return NULL;
}
-static const char *set_max_clients (cmd_parms *cmd, void *dummy,
+static const char *set_max_workers (cmd_parms *cmd, void *dummy,
const char *arg)
{
const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
if (err != NULL) {
return err;
}
-
- max_clients = atoi(arg);
+ if (!strcasecmp(cmd->cmd->name, "MaxRequestWorkers")) {
+ ap_log_error(APLOG_MARK, APLOG_WARNING, 0, NULL,
+ "MaxClients is deprecated, use MaxRequestWorkers "
+ "instead.");
+ }
+ max_workers = atoi(arg);
return NULL;
}
"Minimum number of idle threads, to handle request spikes"),
AP_INIT_TAKE1("MaxSpareThreads", set_max_spare_threads, NULL, RSRC_CONF,
"Maximum number of idle threads"),
-AP_INIT_TAKE1("MaxClients", set_max_clients, NULL, RSRC_CONF,
+AP_INIT_TAKE1("MaxRequestWorkers", set_max_workers, NULL, RSRC_CONF,
"Maximum number of threads alive at the same time"),
+AP_INIT_TAKE1("MaxClients", set_max_workers, NULL, RSRC_CONF,
+ "Deprecated name of MaxRequestWorkers"),
AP_INIT_TAKE1("ThreadsPerChild", set_threads_per_child, NULL, RSRC_CONF,
"Number of threads each child creates"),
AP_INIT_TAKE1("ServerLimit", set_server_limit, NULL, RSRC_CONF,
projects / apache / commitdiff