APR_ADDTO(INCLUDES, [-I\$(top_builddir)/include])
fi
-APR_ADDTO(INCLUDES, [-I\$(top_srcdir)/os/\$(OS_DIR) -I\$(top_srcdir)/server/mpm/\$(MPM_SUBDIR_NAME) -I\$(top_srcdir)/modules/http -I\$(top_srcdir)/modules/aaa -I\$(top_srcdir)/modules/filters -I\$(top_srcdir)/modules/proxy -I\$(top_srcdir)/modules/session -I\$(top_srcdir)/include -I\$(top_srcdir)/modules/generators -I\$(top_srcdir)/modules/mappers -I\$(top_srcdir)/modules/database])
+APR_ADDTO(INCLUDES, [-I\$(top_srcdir)/os/\$(OS_DIR) -I\$(top_srcdir)/modules/http -I\$(top_srcdir)/modules/aaa -I\$(top_srcdir)/modules/filters -I\$(top_srcdir)/modules/proxy -I\$(top_srcdir)/modules/session -I\$(top_srcdir)/include -I\$(top_srcdir)/modules/generators -I\$(top_srcdir)/modules/mappers -I\$(top_srcdir)/modules/database])
# apr/apr-util --includes may pick up system paths for dependent
# libraries, so ensure these are later in INCLUDES than local source
#define AP_MPM_H
#include "apr_thread_proc.h"
+#include "httpd.h"
#ifdef __cplusplus
extern "C" {
*/
/**
- * This is the function that MPMs must create. This function is responsible
- * for controlling the parent and child processes. It will run until a
- * restart/shutdown is indicated.
+ * This is the function that passes control to the MPM for steady-state
+ * processing. It is responsible for controlling the parent and child
+ * processes. It will run until a restart/shutdown is indicated.
* @param pconf the configuration pool, reset before the config file is read
* @param plog the log pool, reset after the config file is read
* @param server_conf the global server config.
#define AP_MPMQ_MAX_DAEMONS 12 /* Max # of daemons by config */
#define AP_MPMQ_MPM_STATE 13 /* starting, running, stopping */
#define AP_MPMQ_IS_ASYNC 14 /* MPM can process async connections */
+#define AP_MPMQ_GENERATION 15 /* MPM generation */
/**
* Query a property of the current MPM.
typedef void (ap_mpm_callback_fn_t)(void *baton);
-/* XXXXXXX: only added support in the Event MPM.... */
-AP_DECLARE(void) ap_mpm_register_timed_callback(apr_time_t t,
- ap_mpm_callback_fn_t *cbfn,
- void *baton);
+/* only added support in the Event MPM.... check for APR_ENOTIMPL */
+AP_DECLARE(apr_status_t) ap_mpm_register_timed_callback(apr_time_t t,
+ ap_mpm_callback_fn_t *cbfn,
+ void *baton);
/* Defining GPROF when compiling uses the moncontrol() function to
* disable gprof profiling in the parent, and enable it only for
#ifndef APACHE_HTTP_MAIN_H
#define APACHE_HTTP_MAIN_H
+#include "httpd.h"
#include "apr_optional.h"
/** AP_SERVER_BASEARGS is the command argument list parsed by http_main.c
AP_DECLARE_DATA extern const char *ap_server_argv0;
/** The global server's ServerRoot */
AP_DECLARE_DATA extern const char *ap_server_root;
+/** The global server's server_rec */
+AP_DECLARE_DATA extern server_rec *ap_server_conf;
/* for -C, -c and -D switches */
/** An array of all -C directives. These are processed before the server's
#define APACHE_MPM_COMMON_H
#include "ap_config.h"
+#include "ap_mpm.h"
#if APR_HAVE_NETINET_TCP_H
#include <netinet/tcp.h> /* for TCP_NODELAY */
#endif
+#ifdef WIN32
+/* XXX temporary mitigation for Windows; other non-Unix MPMs need this hack too
+ * include mpm.h to pick up the AP_MPM_NO_foo definitions
+ */
#include "mpm.h"
+#endif
+
+#ifndef AP_MPM_NO_SET_ACCEPT_LOCK_MECH
+#include "apr_proc_mutex.h"
+#endif
#ifdef __cplusplus
extern "C" {
* in the scoreboard as well as those currently registered via
* ap_register_extra_mpm_process().
*/
-#ifdef AP_MPM_WANT_RECLAIM_CHILD_PROCESSES
+#ifndef AP_MPM_NO_RECLAIM_CHILD_PROCESSES
void ap_reclaim_child_processes(int terminate);
#endif
* in the scoreboard as well as those currently registered via
* ap_register_extra_mpm_process().
*/
-#ifdef AP_MPM_WANT_RECLAIM_CHILD_PROCESSES
+#ifndef AP_MPM_NO_RECLAIM_CHILD_PROCESSES
void ap_relieve_child_processes(void);
#endif
* ap_reclaim_child_processes(), remove it from the list of such processes
* by calling ap_unregister_extra_mpm_process().
*/
-#ifdef AP_MPM_WANT_RECLAIM_CHILD_PROCESSES
+#ifndef AP_MPM_NO_RECLAIM_CHILD_PROCESSES
void ap_register_extra_mpm_process(pid_t pid);
#endif
* be reclaimed.
* @return 1 if the process was found and removed, 0 otherwise
*/
-#ifdef AP_MPM_WANT_RECLAIM_CHILD_PROCESSES
+#ifndef AP_MPM_NO_RECLAIM_CHILD_PROCESSES
int ap_unregister_extra_mpm_process(pid_t pid);
#endif
* APR_EINVAL is returned if passed either an invalid (< 1) pid, or if
* the pid is not in the current process group
*/
-#ifdef AP_MPM_WANT_RECLAIM_CHILD_PROCESSES
+#ifndef AP_MPM_NO_RECLAIM_CHILD_PROCESSES
apr_status_t ap_mpm_safe_kill(pid_t pid, int sig);
#endif
* @param ret The process id of the process that died
* @param p The pool to allocate out of
*/
-#ifdef AP_MPM_WANT_WAIT_OR_TIMEOUT
+#ifndef AP_MPM_NO_WAIT_OR_TIMEOUT
void ap_wait_or_timeout(apr_exit_why_e *status, int *exitcode, apr_proc_t *ret,
apr_pool_t *p);
#endif
* @param status The status returned from ap_wait_or_timeout
* @return 0 on success, APEXIT_CHILDFATAL if MPM should terminate
*/
-#ifdef AP_MPM_WANT_PROCESS_CHILD_STATUS
+#ifndef AP_MPM_NO_PROCESS_CHILD_STATUS
int ap_process_child_status(apr_proc_t *pid, apr_exit_why_e why, int status);
#endif
#define AP_MPM_HARD_LIMITS_FILE APACHE_MPM_DIR "/mpm_default.h"
-#ifdef AP_MPM_USES_POD
+#ifndef AP_MPM_NO_POD
typedef struct ap_pod_t ap_pod_t;
* The maximum number of requests each child thread or
* process handles before dying off
*/
-#ifdef AP_MPM_WANT_SET_MAX_REQUESTS
+#ifndef AP_MPM_NO_SET_MAX_REQUESTS
extern int ap_max_requests_per_child;
const char *ap_mpm_set_max_requests(cmd_parms *cmd, void *dummy,
const char *arg);
/**
* The filename used to store the process id.
*/
-#ifdef AP_MPM_WANT_SET_PIDFILE
+#ifndef AP_MPM_NO_SET_PIDFILE
extern const char *ap_pid_fname;
const char *ap_mpm_set_pidfile(cmd_parms *cmd, void *dummy,
const char *arg);
/**
* The name of lockfile used when Apache needs to lock the accept() call.
*/
-#ifdef AP_MPM_WANT_SET_LOCKFILE
+#ifndef AP_MPM_NO_SET_LOCKFILE
extern const char *ap_lock_fname;
const char *ap_mpm_set_lockfile(cmd_parms *cmd, void *dummy,
const char *arg);
/**
* The system mutex implementation to use for the accept mutex.
*/
-#ifdef AP_MPM_WANT_SET_ACCEPT_LOCK_MECH
+#ifndef AP_MPM_NO_SET_ACCEPT_LOCK_MECH
extern apr_lockmech_e ap_accept_lock_mech;
const char *ap_mpm_set_accept_lock_mech(cmd_parms *cmd, void *dummy,
const char *arg);
/*
* Set the scorboard file.
*/
-#ifdef AP_MPM_WANT_SET_SCOREBOARD
+#ifndef AP_MPM_NO_SET_SCOREBOARD
const char *ap_mpm_set_scoreboard(cmd_parms *cmd, void *dummy,
const char *arg);
#endif
/*
* The directory that the server changes directory to dump core.
*/
-#ifdef AP_MPM_WANT_SET_COREDUMPDIR
+#ifndef AP_MPM_NO_SET_COREDUMPDIR
extern char ap_coredump_dir[MAX_STRING_LEN];
extern int ap_coredumpdir_configured;
const char *ap_mpm_set_coredumpdir(cmd_parms *cmd, void *dummy,
/**
* Set the timeout period for a graceful shutdown.
*/
-#ifdef AP_MPM_WANT_SET_GRACEFUL_SHUTDOWN
+#ifndef AP_MPM_NO_SET_GRACEFUL_SHUTDOWN
extern int ap_graceful_shutdown_timeout;
const char *ap_mpm_set_graceful_shutdown(cmd_parms *cmd, void *dummy,
const char *arg);
#endif
-#ifdef AP_MPM_WANT_SIGNAL_SERVER
+#ifndef AP_MPM_NO_SIGNAL_SERVER
int ap_signal_server(int *, apr_pool_t *);
void ap_mpm_rewrite_args(process_rec *);
#endif
-#ifdef AP_MPM_WANT_SET_MAX_MEM_FREE
+#ifndef AP_MPM_NO_SET_MAX_MEM_FREE
extern apr_uint32_t ap_max_mem_free;
extern const char *ap_mpm_set_max_mem_free(cmd_parms *cmd, void *dummy,
const char *arg);
#endif
-#ifdef AP_MPM_WANT_SET_STACKSIZE
+#ifndef AP_MPM_NO_SET_STACKSIZE
extern apr_size_t ap_thread_stacksize;
extern const char *ap_mpm_set_thread_stacksize(cmd_parms *cmd, void *dummy,
const char *arg);
#endif
-#ifdef AP_MPM_WANT_FATAL_SIGNAL_HANDLER
+#ifndef AP_MPM_NO_FATAL_SIGNAL_HANDLER
extern apr_status_t ap_fatal_signal_setup(server_rec *s, apr_pool_t *pconf);
extern apr_status_t ap_fatal_signal_child_setup(server_rec *s);
#endif
const char *arg);
#endif
+#ifndef AP_MPM_NO_CHILD_PID
+extern pid_t ap_mpm_get_child_pid(int childnum);
+extern pid_t ap_mpm_note_child_killed(int childnum);
+#endif
+
AP_DECLARE_HOOK(int,monitor,(apr_pool_t *p))
/* register modules that undertake to manage system security */
AP_DECLARE(int) ap_sys_privileges_handlers(int inc);
AP_DECLARE_HOOK(int, drop_privileges, (apr_pool_t * pchild, server_rec * s))
+/* pass control to the MPM */
+AP_DECLARE_HOOK(int, mpm, (apr_pool_t *pconf, apr_pool_t *plog, server_rec *s));
+
+/* implement the mpm query function */
+AP_DECLARE_HOOK(apr_status_t, mpm_query, (int query_code, int *result));
+
+/* get pid of child by index */
+AP_DECLARE_HOOK(pid_t, mpm_get_child_pid, (int childnum));
+
+/* child specified by index has been killed */
+AP_DECLARE_HOOK(apr_status_t, mpm_note_child_killed, (int childnum));
+
+/* register the specified callback */
+AP_DECLARE_HOOK(apr_status_t, mpm_register_timed_callback,
+ (apr_time_t t, ap_mpm_callback_fn_t *cbfn, void *baton));
+
#ifdef __cplusplus
}
#endif
char *stat_buffer;
pid_t *pid_buffer, worker_pid;
clock_t tu, ts, tcu, tcs;
- ap_generation_t worker_generation;
+ ap_generation_t mpm_generation, worker_generation;
if (strcmp(r->handler, STATUS_MAGIC_TYPE) &&
strcmp(r->handler, "server-status")) {
return DECLINED;
}
+ ap_mpm_query(AP_MPMQ_GENERATION, &mpm_generation);
+
#ifdef HAVE_TIMES
#ifdef _SC_CLK_TCK
tick = sysconf(_SC_CLK_TCK);
if (!ps_record->quiescing
&& ps_record->pid) {
if (res == SERVER_READY
- && ps_record->generation == ap_my_generation)
+ && ps_record->generation == mpm_generation)
ready++;
else if (res != SERVER_DEAD &&
res != SERVER_STARTING &&
DEFAULT_TIME_FORMAT, 0),
"</dt>\n", NULL);
ap_rprintf(r, "<dt>Parent Server Generation: %d</dt>\n",
- (int)ap_my_generation);
+ (int)mpm_generation);
ap_rputs("<dt>Server uptime: ", r);
show_time(r, up_time);
ap_rputs("</dt>\n", r);
#include "util_script.h"
#include "util_filter.h"
#include "util_ebcdic.h"
-#include "mpm.h"
#include "apr.h"
#include "apr_strings.h"
#define APR_WANT_STRFUNC
#include "http_main.h"
#include "http_vhost.h"
#include "util_cfgtree.h"
-#include "mpm.h"
-
AP_DECLARE_DATA const char *ap_server_argv0 = NULL;
-
AP_DECLARE_DATA const char *ap_server_root = NULL;
+AP_DECLARE_DATA server_rec *ap_server_conf = NULL;
AP_DECLARE_DATA apr_array_header_t *ap_server_pre_read_config = NULL;
AP_DECLARE_DATA apr_array_header_t *ap_server_post_read_config = NULL;
printf(" %s\n", ap_loaded_modules[n]->name);
}
-AP_DECLARE(const char *) ap_show_mpm(void)
-{
- return MPM_NAME;
-}
#include "http_request.h"
#include "http_protocol.h"
#include "ap_mpm.h"
-#include "mpm_default.h"
#include "http_config.h"
#include "http_core.h"
#include "http_vhost.h"
#include "util_filter.h"
#include "util_ebcdic.h"
#include "util_mutex.h"
-#include "mpm.h"
#include "mpm_common.h"
#include "scoreboard.h"
#include "mod_core.h"
#include "apr_buckets.h"
#include "util_filter.h"
#include "util_ebcdic.h"
-#include "mpm.h"
#include "mpm_common.h"
#include "scoreboard.h"
#include "mod_core.h"
#include "http_core.h"
#include "ap_listen.h"
#include "http_log.h"
-#include "mpm.h"
#include "mpm_common.h"
AP_DECLARE_DATA ap_listen_rec *ap_listeners = NULL;
server->sd = s;
server->active = 1;
-#ifdef MPM_ACCEPT_FUNC
- server->accept_func = MPM_ACCEPT_FUNC;
-#else
server->accept_func = NULL;
-#endif
return APR_SUCCESS;
}
* Most significant main() global data can be found in http_config.c
*/
+/* XXX call after module loading based on some cmd-line option/define
+ */
+
static void show_mpm_settings(void)
{
int mpm_query_info;
*/
printf("Architecture: %ld-bit\n", 8 * (long)sizeof(void *));
- show_mpm_settings();
-
printf("Server compiled with....\n");
#ifdef BIG_SECURITY_HOLE
printf(" -D BIG_SECURITY_HOLE\n");
apr_pool_clear(plog);
+ ap_server_conf = server_conf;
if ( ap_run_open_logs(pconf, plog, ptemp, server_conf) != OK) {
ap_log_error(APLOG_MARK, APLOG_STARTUP |APLOG_ERR,
0, NULL, "Unable to open logs");
MPM_DIR=server/mpm/$MPM_SUBDIR_NAME
MPM_LIB=$MPM_DIR/lib${MPM_NAME}.la
-if test ! -f "$abs_srcdir/$MPM_DIR/mpm.h"; then
- AC_MSG_ERROR(the selected mpm -- $apache_cv_mpm -- is not supported)
-fi
-
APACHE_SUBST(MPM_NAME)
APACHE_SUBST(MPM_SUBDIR_NAME)
MODLIST="$MODLIST mpm_${MPM_NAME}"
#include "fdqueue.h"
#include "mpm_default.h"
#include "http_vhost.h"
+#include "unixd.h"
#include <signal.h>
#include <limits.h> /* for INT_MAX */
#define MAX_THREAD_LIMIT 100000
#endif
+#define MPM_CHILD_PID(i) (ap_scoreboard_image->parent[i].pid)
+
/*
* Actual definitions of config globals
*/
-int ap_threads_per_child = 0; /* Worker threads per child */
+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 fd_queue_info_t *worker_queue_info;
static int mpm_state = AP_MPMQ_STARTING;
static int sick_child_detected;
+static ap_generation_t volatile my_generation = 0;
static apr_thread_mutex_t *timeout_mutex;
APR_RING_HEAD(timeout_head_t, conn_state_t);
* use this value to optimize routines that have to scan the entire
* scoreboard.
*/
-int ap_max_daemons_limit = -1;
-
-static ap_pod_t *pod;
+static int max_daemons_limit = -1;
-/* *Non*-shared http_main globals... */
-
-server_rec *ap_server_conf;
+static ap_event_pod_t *pod;
/* The event MPM respects a couple of runtime flags that can aid
* in debugging. Setting the -DNO_DETACH flag will prevent the root process
static void close_worker_sockets(void)
{
int i;
- for (i = 0; i < ap_threads_per_child; i++) {
+ for (i = 0; i < threads_per_child; i++) {
if (worker_sockets[i]) {
apr_socket_close(worker_sockets[i]);
worker_sockets[i] = NULL;
}
}
-AP_DECLARE(apr_status_t) ap_mpm_query(int query_code, int *result)
+static apr_status_t event_query(int query_code, int *result)
{
switch (query_code) {
case AP_MPMQ_MAX_DAEMON_USED:
- *result = ap_max_daemons_limit;
+ *result = max_daemons_limit;
return APR_SUCCESS;
case AP_MPMQ_IS_THREADED:
*result = AP_MPMQ_STATIC;
*result = thread_limit;
return APR_SUCCESS;
case AP_MPMQ_MAX_THREADS:
- *result = ap_threads_per_child;
+ *result = threads_per_child;
return APR_SUCCESS;
case AP_MPMQ_MIN_SPARE_DAEMONS:
*result = 0;
case AP_MPMQ_MPM_STATE:
*result = mpm_state;
return APR_SUCCESS;
+ case AP_MPMQ_GENERATION:
+ *result = my_generation;
+ return APR_SUCCESS;
}
return APR_ENOTIMPL;
}
+static pid_t event_get_child_pid(int childnum)
+{
+ return ap_scoreboard_image->parent[childnum].pid;
+}
+
+static apr_status_t event_note_child_killed(int childnum)
+{
+ ap_scoreboard_image->parent[childnum].pid = 0;
+ return APR_SUCCESS;
+}
+
/* a clean exit from a child with proper cleanup */
static void clean_child_exit(int code) __attribute__ ((noreturn));
static void clean_child_exit(int code)
static int volatile restart_pending;
static int volatile is_graceful;
static volatile int child_fatal;
-ap_generation_t volatile ap_my_generation = 0;
/*
* ap_start_shutdown() and ap_start_restart(), below, are a first stab at
/* Create the main pollset */
rv = apr_pollset_create(&event_pollset,
- ap_threads_per_child,
+ threads_per_child,
p, APR_POLLSET_THREADSAFE | APR_POLLSET_NOCOPY);
if (rv != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_ERR, rv, ap_server_conf,
apr_socket_opt_set(pfd->desc.s, APR_SO_NONBLOCK, 1);
apr_pollset_add(event_pollset, pfd);
+
+ lr->accept_func = ap_unixd_accept;
}
return APR_SUCCESS;
static apr_thread_mutex_t *g_timer_ring_mtx;
-AP_DECLARE(void) ap_mpm_register_timed_callback(apr_time_t t,
- ap_mpm_callback_fn_t *cbfn,
- void *baton)
+static apr_status_t event_register_timed_callback(apr_time_t t,
+ ap_mpm_callback_fn_t *cbfn,
+ void *baton)
{
int inserted = 0;
timer_event_t *ep;
}
apr_thread_mutex_unlock(g_timer_ring_mtx);
+
+ return APR_SUCCESS;
}
#ifndef apr_time_from_msec
ap_scoreboard_image->servers[process_slot][thread_slot].pid = ap_my_pid;
ap_scoreboard_image->servers[process_slot][thread_slot].tid = apr_os_thread_current();
- ap_scoreboard_image->servers[process_slot][thread_slot].generation = ap_my_generation;
+ ap_scoreboard_image->servers[process_slot][thread_slot].generation = my_generation;
ap_update_child_status_from_indexes(process_slot, thread_slot,
SERVER_STARTING, NULL);
/* We must create the fd queues before we start up the listener
* and worker threads. */
worker_queue = apr_pcalloc(pchild, sizeof(*worker_queue));
- rv = ap_queue_init(worker_queue, ap_threads_per_child, pchild);
+ rv = ap_queue_init(worker_queue, threads_per_child, pchild);
if (rv != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_ALERT, rv, ap_server_conf,
"ap_queue_init() failed");
}
rv = ap_queue_info_create(&worker_queue_info, pchild,
- ap_threads_per_child);
+ threads_per_child);
if (rv != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_ALERT, rv, ap_server_conf,
"ap_queue_info_create() failed");
clean_child_exit(APEXIT_CHILDFATAL);
}
- worker_sockets = apr_pcalloc(pchild, ap_threads_per_child
+ worker_sockets = apr_pcalloc(pchild, threads_per_child
* sizeof(apr_socket_t *));
loops = prev_threads_created = 0;
while (1) {
- /* ap_threads_per_child does not include the listener thread */
- for (i = 0; i < ap_threads_per_child; i++) {
+ /* threads_per_child does not include the listener thread */
+ for (i = 0; i < threads_per_child; i++) {
int status =
ap_scoreboard_image->servers[child_num_arg][i].status;
}
- if (start_thread_may_exit || threads_created == ap_threads_per_child) {
+ if (start_thread_may_exit || threads_created == threads_per_child) {
break;
}
/* wait for previous generation to clean up an entry */
"child %" APR_PID_T_FMT " isn't taking over "
"slots very quickly (%d of %d)",
ap_my_pid, threads_created,
- ap_threads_per_child);
+ threads_per_child);
}
prev_threads_created = threads_created;
}
}
}
- for (i = 0; i < ap_threads_per_child; i++) {
+ for (i = 0; i < threads_per_child; i++) {
if (threads[i]) { /* if we ever created this thread */
rv = apr_thread_join(&thread_rv, threads[i]);
if (rv != APR_SUCCESS) {
*/
threads = (apr_thread_t **) calloc(1,
sizeof(apr_thread_t *) *
- ap_threads_per_child);
+ threads_per_child);
if (threads == NULL) {
ap_log_error(APLOG_MARK, APLOG_ALERT, errno, ap_server_conf,
"malloc: out of memory");
apr_signal(SIGTERM, dummy_signal_handler);
/* Watch for any messages from the parent over the POD */
while (1) {
- rv = ap_mpm_pod_check(pod);
+ rv = ap_event_pod_check(pod);
if (rv == AP_NORESTART) {
/* see if termination was triggered while we slept */
switch (terminate_mode) {
{
int pid;
- if (slot + 1 > ap_max_daemons_limit) {
- ap_max_daemons_limit = slot + 1;
+ if (slot + 1 > max_daemons_limit) {
+ max_daemons_limit = slot + 1;
}
if (one_process) {
for (i = 0; i < ap_daemons_limit; ++i) {
/* Initialization to satisfy the compiler. It doesn't know
- * that ap_threads_per_child is always > 0 */
+ * 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;
- if (i >= ap_max_daemons_limit
+ if (i >= max_daemons_limit
&& totally_free_length == idle_spawn_rate)
/* short cut if all active processes have been examined and
* enough empty scoreboard slots have been found
break;
ps = &ap_scoreboard_image->parent[i];
- for (j = 0; j < ap_threads_per_child; j++) {
+ for (j = 0; j < threads_per_child; j++) {
ws = &ap_scoreboard_image->servers[i][j];
status = ws->status;
if (ps->pid != 0) { /* XXX just set all_dead_threads in outer
for loop if no pid? not much else matters */
if (status <= SERVER_READY &&
- !ps->quiescing && ps->generation == ap_my_generation) {
+ !ps->quiescing && ps->generation == my_generation) {
++idle_thread_count;
}
if (status >= SERVER_READY && status < SERVER_GRACEFUL) {
}
}
- ap_max_daemons_limit = last_non_dead + 1;
+ max_daemons_limit = last_non_dead + 1;
if (idle_thread_count > max_spare_threads) {
/* Kill off one child */
- ap_mpm_pod_signal(pod, TRUE);
+ ap_event_pod_signal(pod, TRUE);
idle_spawn_rate = 1;
}
else if (idle_thread_count < min_spare_threads) {
/* terminate the free list */
if (free_length == 0) { /* scoreboard is full, can't fork */
- if (active_thread_count >= ap_daemons_limit * ap_threads_per_child) {
+ if (active_thread_count >= ap_daemons_limit * threads_per_child) {
static int reported = 0;
if (!reported) {
/* only report this condition once */
/* non-fatal death... note that it's gone in the scoreboard. */
child_slot = ap_find_child_by_pid(&pid);
if (child_slot >= 0) {
- for (i = 0; i < ap_threads_per_child; i++)
+ for (i = 0; i < threads_per_child; i++)
ap_update_child_status_from_indexes(child_slot, i,
SERVER_DEAD,
(request_rec *) NULL);
}
}
-int ap_mpm_run(apr_pool_t * _pconf, apr_pool_t * plog, server_rec * s)
+static int event_run(apr_pool_t * _pconf, apr_pool_t * plog, server_rec * s)
{
int remaining_children_to_start;
/* fix the generation number in the global score; we just got a new,
* cleared scoreboard
*/
- ap_scoreboard_image->global->running_generation = ap_my_generation;
+ ap_scoreboard_image->global->running_generation = my_generation;
}
set_signals();
/* Don't thrash... */
- if (max_spare_threads < min_spare_threads + ap_threads_per_child)
- max_spare_threads = min_spare_threads + ap_threads_per_child;
+ if (max_spare_threads < min_spare_threads + threads_per_child)
+ max_spare_threads = min_spare_threads + threads_per_child;
/* 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
/* Time to shut down:
* Kill child processes, tell them to call child_exit, etc...
*/
- ap_mpm_pod_killpg(pod, ap_daemons_limit, FALSE);
+ ap_event_pod_killpg(pod, ap_daemons_limit, FALSE);
ap_reclaim_child_processes(1); /* Start with SIGTERM */
if (!child_fatal) {
/* Close our listeners, and then ask our children to do same */
ap_close_listeners();
- ap_mpm_pod_killpg(pod, ap_daemons_limit, TRUE);
+ ap_event_pod_killpg(pod, ap_daemons_limit, TRUE);
ap_relieve_child_processes();
if (!child_fatal) {
* way, try and make sure that all of our processes are
* really dead.
*/
- ap_mpm_pod_killpg(pod, ap_daemons_limit, FALSE);
+ ap_event_pod_killpg(pod, ap_daemons_limit, FALSE);
ap_reclaim_child_processes(1);
return 1;
/* XXX: we really need to make sure this new generation number isn't in
* use by any of the children.
*/
- ++ap_my_generation;
- ap_scoreboard_image->global->running_generation = ap_my_generation;
+ ++my_generation;
+ ap_scoreboard_image->global->running_generation = my_generation;
if (is_graceful) {
ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, ap_server_conf,
AP_SIG_GRACEFUL_STRING
" received. Doing graceful restart");
/* wake up the children...time to die. But we'll have more soon */
- ap_mpm_pod_killpg(pod, ap_daemons_limit, TRUE);
+ ap_event_pod_killpg(pod, ap_daemons_limit, TRUE);
/* This is mostly for debugging... so that we know what is still
* and a SIGHUP, we may as well use the same signal, because some user
* pthreads are stealing signals from us left and right.
*/
- ap_mpm_pod_killpg(pod, ap_daemons_limit, FALSE);
+ ap_event_pod_killpg(pod, ap_daemons_limit, FALSE);
ap_reclaim_child_processes(1); /* Start with SIGTERM */
ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, ap_server_conf,
apr_status_t rv;
pconf = p;
- ap_server_conf = s;
/* the reverse of pre_config, we want this only the first time around */
if (restart_num++ == 0) {
}
if (!one_process) {
- if ((rv = ap_mpm_pod_open(pconf, &pod))) {
+ if ((rv = ap_event_pod_open(pconf, &pod))) {
ap_log_error(APLOG_MARK, APLOG_CRIT | level_flags, rv,
(startup ? NULL : s),
"could not open pipe-of-death");
server_limit = DEFAULT_SERVER_LIMIT;
thread_limit = DEFAULT_THREAD_LIMIT;
ap_daemons_limit = server_limit;
- ap_threads_per_child = DEFAULT_THREADS_PER_CHILD;
- max_clients = ap_daemons_limit * ap_threads_per_child;
+ threads_per_child = DEFAULT_THREADS_PER_CHILD;
+ max_clients = ap_daemons_limit * threads_per_child;
ap_pid_fname = DEFAULT_PIDLOG;
ap_lock_fname = DEFAULT_LOCKFILE;
ap_max_requests_per_child = DEFAULT_MAX_REQUESTS_PER_CHILD;
thread_limit = first_thread_limit;
}
- if (ap_threads_per_child > thread_limit) {
+ if (threads_per_child > thread_limit) {
if (startup) {
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
"WARNING: ThreadsPerChild of %d exceeds ThreadLimit "
- "of", ap_threads_per_child);
+ "of", threads_per_child);
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
" %d threads, decreasing to %d.",
thread_limit, thread_limit);
ap_log_error(APLOG_MARK, APLOG_WARNING, 0, s,
"ThreadsPerChild of %d exceeds ThreadLimit "
"of %d, decreasing to match",
- ap_threads_per_child, thread_limit);
+ threads_per_child, thread_limit);
}
- ap_threads_per_child = thread_limit;
+ threads_per_child = thread_limit;
}
- else if (ap_threads_per_child < 1) {
+ else if (threads_per_child < 1) {
if (startup) {
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
"WARNING: ThreadsPerChild of %d not allowed, "
- "increasing to 1.", ap_threads_per_child);
+ "increasing to 1.", threads_per_child);
} else {
ap_log_error(APLOG_MARK, APLOG_WARNING, 0, s,
"ThreadsPerChild of %d not allowed, increasing to 1",
- ap_threads_per_child);
+ threads_per_child);
}
- ap_threads_per_child = 1;
+ threads_per_child = 1;
}
- if (max_clients < ap_threads_per_child) {
+ if (max_clients < threads_per_child) {
if (startup) {
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
"WARNING: MaxClients of %d is less than "
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
" %d, increasing to %d. MaxClients must be at "
"least as large",
- ap_threads_per_child, ap_threads_per_child);
+ 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 "
"of %d, increasing to match",
- max_clients, ap_threads_per_child);
+ max_clients, threads_per_child);
}
- max_clients = ap_threads_per_child;
+ max_clients = threads_per_child;
}
- ap_daemons_limit = max_clients / ap_threads_per_child;
+ ap_daemons_limit = max_clients / threads_per_child;
- if (max_clients % ap_threads_per_child) {
- int tmp_max_clients = ap_daemons_limit * ap_threads_per_child;
+ if (max_clients % threads_per_child) {
+ int tmp_max_clients = ap_daemons_limit * threads_per_child;
if (startup) {
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
"multiple of", max_clients);
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
" ThreadsPerChild of %d, decreasing to nearest "
- "multiple %d,", ap_threads_per_child,
+ "multiple %d,", threads_per_child,
tmp_max_clients);
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
" for a maximum of %d servers.",
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, ap_threads_per_child,
+ "multiple %d", max_clients, threads_per_child,
tmp_max_clients);
}
max_clients = tmp_max_clients;
"servers and ", max_clients, 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 * ap_threads_per_child);
+ server_limit, server_limit * threads_per_child);
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
" To increase, please see the ServerLimit "
"directive.");
"MaxClients of %d would require %d servers and "
"exceed ServerLimit of %d, decreasing to %d",
max_clients, ap_daemons_limit, server_limit,
- server_limit * ap_threads_per_child);
+ server_limit * threads_per_child);
}
ap_daemons_limit = server_limit;
}
min_spare_threads = 1;
}
- /* max_spare_threads < min_spare_threads + ap_threads_per_child
+ /* max_spare_threads < min_spare_threads + threads_per_child
* checked in ap_mpm_run()
*/
*/
ap_hook_pre_config(event_pre_config, NULL, NULL, APR_HOOK_REALLY_FIRST);
ap_hook_check_config(event_check_config, NULL, NULL, APR_HOOK_MIDDLE);
+ ap_hook_mpm(event_run, NULL, NULL, APR_HOOK_MIDDLE);
+ ap_hook_mpm_query(event_query, NULL, NULL, APR_HOOK_MIDDLE);
+ ap_hook_mpm_get_child_pid(event_get_child_pid, NULL, NULL, APR_HOOK_MIDDLE);
+ ap_hook_mpm_note_child_killed(event_note_child_killed, NULL, NULL, APR_HOOK_MIDDLE);
+ ap_hook_mpm_register_timed_callback(event_register_timed_callback, NULL, NULL,
+ APR_HOOK_MIDDLE);
}
static const char *set_daemons_to_start(cmd_parms *cmd, void *dummy,
return err;
}
- ap_threads_per_child = atoi(arg);
+ threads_per_child = atoi(arg);
return NULL;
}
static const char *set_server_limit (cmd_parms *cmd, void *dummy, const char *arg)
+++ /dev/null
-/* 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.
- */
-
-/**
- * @file event/mpm.h
- * @brief Unix Exent driven MPM
- *
- * @defgroup APACHE_MPM_EVENT Unix Event MPM
- * @ingroup APACHE_OS_UNIX APACHE_MPM
- * @{
- */
-
-#include "scoreboard.h"
-#include "unixd.h"
-
-#ifndef APACHE_MPM_EVENT_H
-#define APACHE_MPM_EVENT_H
-
-#define EVENT_MPM
-
-#define MPM_NAME "Event"
-
-#define AP_MPM_WANT_RECLAIM_CHILD_PROCESSES
-#define AP_MPM_WANT_WAIT_OR_TIMEOUT
-#define AP_MPM_WANT_PROCESS_CHILD_STATUS
-#define AP_MPM_WANT_SET_PIDFILE
-#define AP_MPM_WANT_SET_SCOREBOARD
-#define AP_MPM_WANT_SET_LOCKFILE
-#define AP_MPM_WANT_SET_MAX_REQUESTS
-#define AP_MPM_WANT_SET_COREDUMPDIR
-#define AP_MPM_WANT_SET_ACCEPT_LOCK_MECH
-#define AP_MPM_WANT_SIGNAL_SERVER
-#define AP_MPM_WANT_SET_MAX_MEM_FREE
-#define AP_MPM_WANT_SET_STACKSIZE
-#define AP_MPM_WANT_SET_GRACEFUL_SHUTDOWN
-#define AP_MPM_WANT_FATAL_SIGNAL_HANDLER
-#define AP_MPM_DISABLE_NAGLE_ACCEPTED_SOCK
-
-#define AP_MPM_HAS_USER_CALLBACKS
-
-#define MPM_CHILD_PID(i) (ap_scoreboard_image->parent[i].pid)
-#define MPM_NOTE_CHILD_KILLED(i) (MPM_CHILD_PID(i) = 0)
-#define MPM_ACCEPT_FUNC ap_unixd_accept
-
-extern int ap_threads_per_child;
-extern int ap_max_daemons_limit;
-extern server_rec *ap_server_conf;
-extern char ap_coredump_dir[MAX_STRING_LEN];
-
-#endif /* APACHE_MPM_EVENT_H */
-/** @} */
#include "pod.h"
+#include "apr_portable.h"
+
#if APR_HAVE_UNISTD_H
#include <unistd.h>
#endif
-AP_DECLARE(apr_status_t) ap_mpm_pod_open(apr_pool_t * p, ap_pod_t ** pod)
+AP_DECLARE(apr_status_t) ap_event_pod_open(apr_pool_t * p, ap_event_pod_t ** pod)
{
apr_status_t rv;
return APR_SUCCESS;
}
-AP_DECLARE(int) ap_mpm_pod_check(ap_pod_t * pod)
+AP_DECLARE(int) ap_event_pod_check(ap_event_pod_t * pod)
{
char c;
apr_os_file_t fd;
return AP_NORESTART;
}
-AP_DECLARE(apr_status_t) ap_mpm_pod_close(ap_pod_t * pod)
+AP_DECLARE(apr_status_t) ap_event_pod_close(ap_event_pod_t * pod)
{
apr_status_t rv;
return rv;
}
-static apr_status_t pod_signal_internal(ap_pod_t * pod, int graceful)
+static apr_status_t pod_signal_internal(ap_event_pod_t * pod, int graceful)
{
apr_status_t rv;
char char_of_death = graceful ? GRACEFUL_CHAR : RESTART_CHAR;
return rv;
}
-AP_DECLARE(apr_status_t) ap_mpm_pod_signal(ap_pod_t * pod, int graceful)
+AP_DECLARE(apr_status_t) ap_event_pod_signal(ap_event_pod_t * pod, int graceful)
{
return pod_signal_internal(pod, graceful);
}
-AP_DECLARE(void) ap_mpm_pod_killpg(ap_pod_t * pod, int num, int graceful)
+AP_DECLARE(void) ap_event_pod_killpg(ap_event_pod_t * pod, int num, int graceful)
{
int i;
apr_status_t rv = APR_SUCCESS;
#include "http_config.h"
#include "http_log.h"
#include "http_main.h"
-#include "mpm.h"
#include "mpm_common.h"
#include "ap_mpm.h"
#include "ap_listen.h"
#define AP_RESTART 0
#define AP_GRACEFUL 1
-typedef struct ap_pod_t ap_pod_t;
+typedef struct ap_event_pod_t ap_event_pod_t;
-struct ap_pod_t
+struct ap_event_pod_t
{
apr_file_t *pod_in;
apr_file_t *pod_out;
apr_pool_t *p;
};
-AP_DECLARE(apr_status_t) ap_mpm_pod_open(apr_pool_t * p, ap_pod_t ** pod);
-AP_DECLARE(int) ap_mpm_pod_check(ap_pod_t * pod);
-AP_DECLARE(apr_status_t) ap_mpm_pod_close(ap_pod_t * pod);
-AP_DECLARE(apr_status_t) ap_mpm_pod_signal(ap_pod_t * pod, int graceful);
-AP_DECLARE(void) ap_mpm_pod_killpg(ap_pod_t * pod, int num, int graceful);
+AP_DECLARE(apr_status_t) ap_event_pod_open(apr_pool_t * p, ap_event_pod_t ** pod);
+AP_DECLARE(int) ap_event_pod_check(ap_event_pod_t * pod);
+AP_DECLARE(apr_status_t) ap_event_pod_close(ap_event_pod_t * pod);
+AP_DECLARE(apr_status_t) ap_event_pod_signal(ap_event_pod_t * pod, int graceful);
+AP_DECLARE(void) ap_event_pod_killpg(ap_event_pod_t * pod, int num, int graceful);
/** @} */
+++ /dev/null
-/* 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.
- */
-
-/**
- * @file prefork/mpm.h
- * @brief Unix Prefork MPM (default for Uinx systems)
- *
- * @defgroup APACHE_MPM_PREFORK Unix Prefork
- * @ingroup APACHE_MPM APACHE_OS_UNIX
- * @{
- */
-
-#include "httpd.h"
-#include "mpm_default.h"
-#include "scoreboard.h"
-#include "unixd.h"
-
-#ifndef APACHE_MPM_PREFORK_H
-#define APACHE_MPM_PREFORK_H
-
-#define PREFORK_MPM
-
-#define MPM_NAME "Prefork"
-
-#define AP_MPM_WANT_RECLAIM_CHILD_PROCESSES
-#define AP_MPM_WANT_WAIT_OR_TIMEOUT
-#define AP_MPM_WANT_PROCESS_CHILD_STATUS
-#define AP_MPM_WANT_SET_PIDFILE
-#define AP_MPM_WANT_SET_SCOREBOARD
-#define AP_MPM_WANT_SET_LOCKFILE
-#define AP_MPM_WANT_SET_MAX_REQUESTS
-#define AP_MPM_WANT_SET_COREDUMPDIR
-#define AP_MPM_WANT_SET_ACCEPT_LOCK_MECH
-#define AP_MPM_WANT_SIGNAL_SERVER
-#define AP_MPM_WANT_SET_MAX_MEM_FREE
-#define AP_MPM_WANT_FATAL_SIGNAL_HANDLER
-#define AP_MPM_WANT_SET_GRACEFUL_SHUTDOWN
-#define AP_MPM_DISABLE_NAGLE_ACCEPTED_SOCK
-
-#define AP_MPM_USES_POD 1
-#define MPM_CHILD_PID(i) (ap_scoreboard_image->parent[i].pid)
-#define MPM_NOTE_CHILD_KILLED(i) (MPM_CHILD_PID(i) = 0)
-#define MPM_ACCEPT_FUNC ap_unixd_accept
-
-extern int ap_threads_per_child;
-extern int ap_max_daemons_limit;
-extern server_rec *ap_server_conf;
-#endif /* APACHE_MPM_PREFORK_H */
-/** @} */
/* config globals */
-int ap_threads_per_child=0; /* Worker threads per child */
static apr_proc_mutex_t *accept_mutex;
static int ap_daemons_to_start=0;
static int ap_daemons_min_free=0;
static int mpm_state = AP_MPMQ_STARTING;
static ap_pod_t *pod;
+#define MPM_CHILD_PID(i) (ap_scoreboard_image->parent[i].pid)
+
/*
* The max child slot ever assigned, preserved across restarts. Necessary
* to deal with MaxClients changes across AP_SIG_GRACEFUL restarts. We
* use this value to optimize routines that have to scan the entire scoreboard.
*/
-int ap_max_daemons_limit = -1;
-server_rec *ap_server_conf;
+static int max_daemons_limit = -1;
/* 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
#ifndef MULTITHREAD
static int my_child_num;
#endif
-ap_generation_t volatile ap_my_generation=0;
+static ap_generation_t volatile my_generation=0;
#ifdef TPF
int tpf_child = 0;
if (rv != APR_SUCCESS) {
const char *msg = "couldn't grab the accept mutex";
- if (ap_my_generation !=
+ if (my_generation !=
ap_scoreboard_image->global->running_generation) {
ap_log_error(APLOG_MARK, APLOG_DEBUG, rv, NULL, "%s", msg);
clean_child_exit(0);
if (rv != APR_SUCCESS) {
const char *msg = "couldn't release the accept mutex";
- if (ap_my_generation !=
+ if (my_generation !=
ap_scoreboard_image->global->running_generation) {
ap_log_error(APLOG_MARK, APLOG_DEBUG, rv, NULL, "%s", msg);
/* don't exit here... we have a connection to
#define SAFE_ACCEPT(stmt) do {stmt;} while(0)
#endif
-AP_DECLARE(apr_status_t) ap_mpm_query(int query_code, int *result)
+static apr_status_t prefork_query(int query_code, int *result)
{
switch(query_code){
case AP_MPMQ_MAX_DAEMON_USED:
case AP_MPMQ_MPM_STATE:
*result = mpm_state;
return APR_SUCCESS;
+ case AP_MPMQ_GENERATION:
+ *result = my_generation;
+ return APR_SUCCESS;
}
return APR_ENOTIMPL;
}
+static pid_t prefork_get_child_pid(int childnum)
+{
+ return ap_scoreboard_image->parent[childnum].pid;
+}
+
+static apr_status_t prefork_note_child_killed(int childnum)
+{
+ ap_scoreboard_image->parent[childnum].pid = 0;
+ return APR_SUCCESS;
+}
+
/*****************************************************************
* Connection structures and accounting...
*/
/* ### check the status */
(void) apr_pollset_add(pollset, &pfd);
+
+ lr->accept_func = ap_unixd_accept;
}
mpm_state = AP_MPMQ_RUNNING;
if (ap_mpm_pod_check(pod) == APR_SUCCESS) { /* selected as idle? */
die_now = 1;
}
- else if (ap_my_generation !=
+ else if (my_generation !=
ap_scoreboard_image->global->running_generation) { /* restart? */
/* yeah, this could be non-graceful restart, in which case the
* parent will kill us soon enough, but why bother checking?
{
int pid;
- if (slot + 1 > ap_max_daemons_limit) {
- ap_max_daemons_limit = slot + 1;
+ if (slot + 1 > max_daemons_limit) {
+ max_daemons_limit = slot + 1;
}
if (one_process) {
for (i = 0; i < ap_daemons_limit; ++i) {
int status;
- if (i >= ap_max_daemons_limit && free_length == idle_spawn_rate)
+ if (i >= max_daemons_limit && free_length == idle_spawn_rate)
break;
ws = &ap_scoreboard_image->servers[i][0];
status = ws->status;
last_non_dead = i;
}
}
- ap_max_daemons_limit = last_non_dead + 1;
+ max_daemons_limit = last_non_dead + 1;
if (idle_count > ap_daemons_max_free) {
/* 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
* Executive routines.
*/
-int ap_mpm_run(apr_pool_t *_pconf, apr_pool_t *plog, server_rec *s)
+static int prefork_run(apr_pool_t *_pconf, apr_pool_t *plog, server_rec *s)
{
int index;
int remaining_children_to_start;
/* fix the generation number in the global score; we just got a new,
* cleared scoreboard
*/
- ap_scoreboard_image->global->running_generation = ap_my_generation;
+ ap_scoreboard_image->global->running_generation = my_generation;
}
set_signals();
ap_close_listeners();
/* kill off the idle ones */
- ap_mpm_pod_killpg(pod, ap_max_daemons_limit);
+ ap_mpm_pod_killpg(pod, max_daemons_limit);
/* Send SIGUSR1 to the active children */
active_children = 0;
/* XXX: we really need to make sure this new generation number isn't in
* use by any of the children.
*/
- ++ap_my_generation;
- ap_scoreboard_image->global->running_generation = ap_my_generation;
+ ++my_generation;
+ ap_scoreboard_image->global->running_generation = my_generation;
if (is_graceful) {
ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, ap_server_conf,
"Graceful restart requested, doing restart");
/* kill off the idle ones */
- ap_mpm_pod_killpg(pod, ap_max_daemons_limit);
+ ap_mpm_pod_killpg(pod, max_daemons_limit);
/* This is mostly for debugging... so that we know what is still
* gracefully dealing with existing request. This will break
ap_daemons_limit = 1;
}
- /* ap_daemons_to_start > ap_daemons_limit checked in ap_mpm_run() */
+ /* ap_daemons_to_start > ap_daemons_limit checked in prefork_run() */
if (ap_daemons_to_start < 0) {
if (startup) {
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
ap_daemons_min_free = 1;
}
- /* ap_daemons_max_free < ap_daemons_min_free + 1 checked in ap_mpm_run() */
+ /* ap_daemons_max_free < ap_daemons_min_free + 1 checked in prefork_run() */
return OK;
}
*/
ap_hook_pre_config(prefork_pre_config, NULL, NULL, APR_HOOK_REALLY_FIRST);
ap_hook_check_config(prefork_check_config, NULL, NULL, APR_HOOK_MIDDLE);
+ ap_hook_mpm(prefork_run, NULL, NULL, APR_HOOK_MIDDLE);
+ ap_hook_mpm_query(prefork_query, NULL, NULL, APR_HOOK_MIDDLE);
+ ap_hook_mpm_get_child_pid(prefork_get_child_pid, NULL, NULL, APR_HOOK_MIDDLE);
+ ap_hook_mpm_note_child_killed(prefork_note_child_killed, NULL, NULL, APR_HOOK_MIDDLE);
}
static const char *set_daemons_to_start(cmd_parms *cmd, void *dummy, const char *arg)
+++ /dev/null
-/* 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.
- */
-
-#include "httpd.h"
-
-#ifndef APACHE_MPM_SIMPLE_H
-#define APACHE_MPM_SIMPLE_H
-
-#define MPM_NAME "Simple"
-
-/* pqXXXXXX: shouldn't need this really. */
-#define AP_MPM_WANT_SIGNAL_SERVER
-
-/* pqXXXXXX: signal server has a hidden dependency */
-#define AP_MPM_WANT_SET_PIDFILE
-
-extern server_rec *ap_server_conf;
-
-#endif /* APACHE_MPM_SIMPLE_H */
* limitations under the License.
*/
-#include "mpm.h"
#include "ap_mpm.h"
#include "httpd.h"
#include "http_config.h"
#include "simple_run.h"
#include "http_core.h"
-/* Thie file contains the absolute minimal MPM API, to interface with httpd. */
+/* This file contains the absolute minimal MPM API, to interface with httpd. */
-ap_generation_t volatile ap_my_generation = 0;
-server_rec *ap_server_conf = NULL;
-
-
- int ap_mpm_run(apr_pool_t * pconf, apr_pool_t * plog, server_rec * s)
+static int simple_run(apr_pool_t * pconf, apr_pool_t * plog, server_rec * s)
{
simple_core_t *sc = simple_core_get();
return simple_main_loop(sc);
}
-apr_status_t ap_mpm_query(int query_code, int *result)
+static apr_status_t simple_query(int query_code, int *result)
{
simple_core_t *sc = simple_core_get();
case AP_MPMQ_MPM_STATE:
*result = sc->mpm_state;
return APR_SUCCESS;
+ case AP_MPMQ_GENERATION:
+ *result = 0;
+ return APR_SUCCESS;
default:
break;
}
{
int nsock;
- ap_server_conf = s;
-
nsock = ap_setup_listeners(s);
if (nsock < 1) {
ap_hook_check_config(simple_check_config, NULL, NULL, APR_HOOK_MIDDLE);
+ ap_hook_mpm(simple_run, NULL, NULL, APR_HOOK_MIDDLE);
+
+ ap_hook_mpm_query(simple_query, NULL, NULL, APR_HOOK_MIDDLE);
}
static const char *set_proccount(cmd_parms * cmd, void *baton,
#define MPM_NAME "WinNT"
-#define AP_MPM_WANT_SET_PIDFILE
-#define AP_MPM_WANT_SET_MAX_REQUESTS
-#define AP_MPM_WANT_SET_SCOREBOARD
-#define AP_MPM_WANT_SET_MAX_MEM_FREE
-#define AP_MPM_WANT_SET_STACKSIZE
+#define AP_MPM_NO_SET_ACCEPT_LOCK_MECH
+#define AP_MPM_NO_RECLAIM_CHILD_PROCESSES
+#define AP_MPM_NO_WAIT_OR_TIMEOUT
+#define AP_MPM_NO_PROCESS_CHILD_STATUS
+#define AP_MPM_NO_POD
+#define AP_MPM_NO_SET_LOCKFILE
+#define AP_MPM_NO_SET_COREDUMPDIR
+#define AP_MPM_NO_SET_SCOREBOARD
+#define AP_MPM_NO_SET_GRACEFUL_SHUTDOWN
+#define AP_MPM_NO_SIGNAL_SERVER
+#define AP_MPM_NO_FATAL_SIGNAL_HANDLER
extern int ap_threads_per_child;
extern int ap_thread_limit;
-extern server_rec *ap_server_conf;
#endif /* APACHE_MPM_H */
/** @} */
*/
extern apr_shm_t *ap_scoreboard_shm;
-/* ap_my_generation are used by the scoreboard code */
-ap_generation_t volatile ap_my_generation=0;
+/* my_generation is returned to the scoreboard code */
+static ap_generation_t volatile my_generation=0;
/* Definitions of WINNT MPM specific config globals */
static HANDLE shutdown_event; /* used to signal the parent to shutdown */
*/
apr_pool_t *pconf;
-/* on several occasions we don't have the global server context
- * although it's needed for logging, etc.
- */
-server_rec *ap_server_conf;
-
/* definitions from child.c */
void child_main(apr_pool_t *pconf);
event_handles[CHILD_HANDLE] = NULL;
}
if (restart_pending) {
- ++ap_my_generation;
- ap_scoreboard_image->global->running_generation = ap_my_generation;
+ ++my_generation;
+ ap_scoreboard_image->global->running_generation = my_generation;
}
die_now:
if (shutdown_pending)
* service after we preflight the config.
*/
-AP_DECLARE(apr_status_t) ap_mpm_query(int query_code, int *result)
+static apr_status_t winnt_query(int query_code, int *result)
{
switch(query_code){
case AP_MPMQ_MAX_DAEMON_USED:
case AP_MPMQ_MPM_STATE:
*result = winnt_mpm_state;
return APR_SUCCESS;
+ case AP_MPMQ_GENERATION:
+ *result = my_generation;
+ return APR_SUCCESS;
}
return APR_ENOTIMPL;
}
service_name);
exit(APEXIT_INIT);
}
- else if (!one_process && !ap_my_generation) {
+ else if (!one_process && !my_generation) {
/* Open a null handle to soak stdout in this process.
* We need to emulate apr_proc_detach, unix performs this
* same check in the pre_config hook (although it is
/* Done reading from the parent, close that channel */
CloseHandle(pipe);
- ap_my_generation = ap_scoreboard_image->global->running_generation;
+ my_generation = ap_scoreboard_image->global->running_generation;
}
else {
/* Single process mode - this lock doesn't even need to exist */
}
-AP_DECLARE(int) ap_mpm_run(apr_pool_t *_pconf, apr_pool_t *plog, server_rec *s )
+static int winnt_run(apr_pool_t *_pconf, apr_pool_t *plog, server_rec *s )
{
static int restart = 0; /* Default is "not a restart" */
ap_hook_post_config(winnt_post_config, NULL, NULL, 0);
ap_hook_child_init(winnt_child_init, NULL, NULL, APR_HOOK_MIDDLE);
ap_hook_open_logs(winnt_open_logs, NULL, aszSucc, APR_HOOK_REALLY_FIRST);
+ ap_hook_mpm(winnt_run, NULL, NULL, APR_HOOK_MIDDLE);
+ ap_hook_mpm_query(winnt_query, NULL, NULL, APR_HOOK_MIDDLE);
}
AP_MODULE_DECLARE_DATA module mpm_winnt_module = {
+++ /dev/null
-/* 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.
- */
-
-/**
- * @file worker/mpm.h
- * @brief Unix Worker MPM
- *
- * @defgroup APACHE_MPM_WORKER Unix Worker MPM
- * @ingroup APACHE_OS_UNIX APACHE_MPM
- * @{
- */
-
-#include "scoreboard.h"
-#include "unixd.h"
-
-#ifndef APACHE_MPM_WORKER_H
-#define APACHE_MPM_WORKER_H
-
-#define WORKER_MPM
-
-#define MPM_NAME "Worker"
-
-#define AP_MPM_WANT_RECLAIM_CHILD_PROCESSES
-#define AP_MPM_WANT_WAIT_OR_TIMEOUT
-#define AP_MPM_WANT_PROCESS_CHILD_STATUS
-#define AP_MPM_WANT_SET_PIDFILE
-#define AP_MPM_WANT_SET_SCOREBOARD
-#define AP_MPM_WANT_SET_LOCKFILE
-#define AP_MPM_WANT_SET_MAX_REQUESTS
-#define AP_MPM_WANT_SET_COREDUMPDIR
-#define AP_MPM_WANT_SET_ACCEPT_LOCK_MECH
-#define AP_MPM_WANT_SIGNAL_SERVER
-#define AP_MPM_WANT_SET_MAX_MEM_FREE
-#define AP_MPM_WANT_SET_STACKSIZE
-#define AP_MPM_WANT_SET_GRACEFUL_SHUTDOWN
-#define AP_MPM_WANT_FATAL_SIGNAL_HANDLER
-#define AP_MPM_DISABLE_NAGLE_ACCEPTED_SOCK
-
-#define MPM_CHILD_PID(i) (ap_scoreboard_image->parent[i].pid)
-#define MPM_NOTE_CHILD_KILLED(i) (MPM_CHILD_PID(i) = 0)
-#define MPM_ACCEPT_FUNC ap_unixd_accept
-
-extern int ap_threads_per_child;
-extern int ap_max_daemons_limit;
-extern server_rec *ap_server_conf;
-extern char ap_coredump_dir[MAX_STRING_LEN];
-
-#endif /* APACHE_MPM_WORKER_H */
-/** @} */
* limitations under the License.
*/
+#include "apr_portable.h"
#include "pod.h"
#if APR_HAVE_UNISTD_H
#include <unistd.h>
#endif
-AP_DECLARE(apr_status_t) ap_mpm_pod_open(apr_pool_t *p, ap_pod_t **pod)
+AP_DECLARE(apr_status_t) ap_worker_pod_open(apr_pool_t *p, ap_worker_pod_t **pod)
{
apr_status_t rv;
return APR_SUCCESS;
}
-AP_DECLARE(int) ap_mpm_pod_check(ap_pod_t *pod)
+AP_DECLARE(int) ap_worker_pod_check(ap_worker_pod_t *pod)
{
char c;
apr_os_file_t fd;
return AP_NORESTART;
}
-AP_DECLARE(apr_status_t) ap_mpm_pod_close(ap_pod_t *pod)
+AP_DECLARE(apr_status_t) ap_worker_pod_close(ap_worker_pod_t *pod)
{
apr_status_t rv;
return rv;
}
-static apr_status_t pod_signal_internal(ap_pod_t *pod, int graceful)
+static apr_status_t pod_signal_internal(ap_worker_pod_t *pod, int graceful)
{
apr_status_t rv;
char char_of_death = graceful ? GRACEFUL_CHAR : RESTART_CHAR;
return rv;
}
-AP_DECLARE(apr_status_t) ap_mpm_pod_signal(ap_pod_t *pod, int graceful)
+AP_DECLARE(apr_status_t) ap_worker_pod_signal(ap_worker_pod_t *pod, int graceful)
{
return pod_signal_internal(pod, graceful);
}
-AP_DECLARE(void) ap_mpm_pod_killpg(ap_pod_t *pod, int num, int graceful)
+AP_DECLARE(void) ap_worker_pod_killpg(ap_worker_pod_t *pod, int num, int graceful)
{
int i;
apr_status_t rv = APR_SUCCESS;
#include "http_config.h"
#include "http_log.h"
#include "http_main.h"
-#include "mpm.h"
#include "mpm_common.h"
#include "ap_mpm.h"
#include "ap_listen.h"
#define AP_RESTART 0
#define AP_GRACEFUL 1
-typedef struct ap_pod_t ap_pod_t;
+typedef struct ap_worker_pod_t ap_worker_pod_t;
-struct ap_pod_t {
+struct ap_worker_pod_t {
apr_file_t *pod_in;
apr_file_t *pod_out;
apr_pool_t *p;
};
-AP_DECLARE(apr_status_t) ap_mpm_pod_open(apr_pool_t *p, ap_pod_t **pod);
-AP_DECLARE(int) ap_mpm_pod_check(ap_pod_t *pod);
-AP_DECLARE(apr_status_t) ap_mpm_pod_close(ap_pod_t *pod);
-AP_DECLARE(apr_status_t) ap_mpm_pod_signal(ap_pod_t *pod, int graceful);
-AP_DECLARE(void) ap_mpm_pod_killpg(ap_pod_t *pod, int num, int graceful);
+AP_DECLARE(apr_status_t) ap_worker_pod_open(apr_pool_t *p, ap_worker_pod_t **pod);
+AP_DECLARE(int) ap_worker_pod_check(ap_worker_pod_t *pod);
+AP_DECLARE(apr_status_t) ap_worker_pod_close(ap_worker_pod_t *pod);
+AP_DECLARE(apr_status_t) ap_worker_pod_signal(ap_worker_pod_t *pod, int graceful);
+AP_DECLARE(void) ap_worker_pod_killpg(ap_worker_pod_t *pod, int num, int graceful);
/** @} */
#include "scoreboard.h"
#include "fdqueue.h"
#include "mpm_default.h"
+#include "unixd.h"
#include <signal.h>
#include <limits.h> /* for INT_MAX */
* Actual definitions of config globals
*/
-int ap_threads_per_child = 0; /* Worker threads per child */
+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 fd_queue_info_t *worker_queue_info;
static int mpm_state = AP_MPMQ_STARTING;
static int sick_child_detected;
+static ap_generation_t volatile my_generation = 0;
+
+#define MPM_CHILD_PID(i) (ap_scoreboard_image->parent[i].pid)
/* The structure used to pass unique initialization info to each thread */
typedef struct {
* use this value to optimize routines that have to scan the entire
* scoreboard.
*/
-int ap_max_daemons_limit = -1;
-
-static ap_pod_t *pod;
-
-/* *Non*-shared http_main globals... */
+static int max_daemons_limit = -1;
-server_rec *ap_server_conf;
+static ap_worker_pod_t *pod;
/* The worker MPM respects a couple of runtime flags that can aid
* in debugging. Setting the -DNO_DETACH flag will prevent the root process
static void close_worker_sockets(void)
{
int i;
- for (i = 0; i < ap_threads_per_child; i++) {
+ for (i = 0; i < threads_per_child; i++) {
if (worker_sockets[i]) {
apr_socket_close(worker_sockets[i]);
worker_sockets[i] = NULL;
}
}
-AP_DECLARE(apr_status_t) ap_mpm_query(int query_code, int *result)
+static apr_status_t worker_query(int query_code, int *result)
{
switch(query_code){
case AP_MPMQ_MAX_DAEMON_USED:
- *result = ap_max_daemons_limit;
+ *result = max_daemons_limit;
return APR_SUCCESS;
case AP_MPMQ_IS_THREADED:
*result = AP_MPMQ_STATIC;
*result = thread_limit;
return APR_SUCCESS;
case AP_MPMQ_MAX_THREADS:
- *result = ap_threads_per_child;
+ *result = threads_per_child;
return APR_SUCCESS;
case AP_MPMQ_MIN_SPARE_DAEMONS:
*result = 0;
case AP_MPMQ_MPM_STATE:
*result = mpm_state;
return APR_SUCCESS;
+ case AP_MPMQ_GENERATION:
+ *result = my_generation;
+ return APR_SUCCESS;
}
return APR_ENOTIMPL;
}
+static pid_t worker_get_child_pid(int childnum)
+{
+ return ap_scoreboard_image->parent[childnum].pid;
+}
+
+static apr_status_t worker_note_child_killed(int childnum)
+{
+ ap_scoreboard_image->parent[childnum].pid = 0;
+ return APR_SUCCESS;
+}
+
/* a clean exit from a child with proper cleanup */
static void clean_child_exit(int code) __attribute__ ((noreturn));
static void clean_child_exit(int code)
static int volatile restart_pending;
static int volatile is_graceful;
static volatile int child_fatal;
-ap_generation_t volatile ap_my_generation = 0;
/*
* ap_start_shutdown() and ap_start_restart(), below, are a first stab at
/* ### check the status */
(void) apr_pollset_add(pollset, &pfd);
+
+ lr->accept_func = ap_unixd_accept;
}
/* Unblock the signal used to wake this thread up, and set a handler for
ap_scoreboard_image->servers[process_slot][thread_slot].pid = ap_my_pid;
ap_scoreboard_image->servers[process_slot][thread_slot].tid = apr_os_thread_current();
- ap_scoreboard_image->servers[process_slot][thread_slot].generation = ap_my_generation;
+ ap_scoreboard_image->servers[process_slot][thread_slot].generation = my_generation;
ap_update_child_status_from_indexes(process_slot, thread_slot, SERVER_STARTING, NULL);
#ifdef HAVE_PTHREAD_KILL
/* We must create the fd queues before we start up the listener
* and worker threads. */
worker_queue = apr_pcalloc(pchild, sizeof(*worker_queue));
- rv = ap_queue_init(worker_queue, ap_threads_per_child, pchild);
+ rv = ap_queue_init(worker_queue, threads_per_child, pchild);
if (rv != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_ALERT, rv, ap_server_conf,
"ap_queue_init() failed");
}
rv = ap_queue_info_create(&worker_queue_info, pchild,
- ap_threads_per_child);
+ threads_per_child);
if (rv != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_ALERT, rv, ap_server_conf,
"ap_queue_info_create() failed");
clean_child_exit(APEXIT_CHILDFATAL);
}
- worker_sockets = apr_pcalloc(pchild, ap_threads_per_child
+ worker_sockets = apr_pcalloc(pchild, threads_per_child
* sizeof(apr_socket_t *));
loops = prev_threads_created = 0;
while (1) {
- /* ap_threads_per_child does not include the listener thread */
- for (i = 0; i < ap_threads_per_child; i++) {
+ /* threads_per_child does not include the listener thread */
+ for (i = 0; i < threads_per_child; i++) {
int status = ap_scoreboard_image->servers[child_num_arg][i].status;
if (status != SERVER_GRACEFUL && status != SERVER_DEAD) {
create_listener_thread(ts);
listener_started = 1;
}
- if (start_thread_may_exit || threads_created == ap_threads_per_child) {
+ if (start_thread_may_exit || threads_created == threads_per_child) {
break;
}
/* wait for previous generation to clean up an entry */
ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ap_server_conf,
"child %" APR_PID_T_FMT " isn't taking over "
"slots very quickly (%d of %d)",
- ap_my_pid, threads_created, ap_threads_per_child);
+ ap_my_pid, threads_created, threads_per_child);
}
prev_threads_created = threads_created;
}
}
}
- for (i = 0; i < ap_threads_per_child; i++) {
+ for (i = 0; i < threads_per_child; i++) {
if (threads[i]) { /* if we ever created this thread */
#ifdef HAVE_PTHREAD_KILL
apr_os_thread_t *worker_os_thread;
* and we want a 0 entry to indicate a thread which was not created
*/
threads = (apr_thread_t **)calloc(1,
- sizeof(apr_thread_t *) * ap_threads_per_child);
+ sizeof(apr_thread_t *) * threads_per_child);
if (threads == NULL) {
ap_log_error(APLOG_MARK, APLOG_ALERT, errno, ap_server_conf,
"malloc: out of memory");
apr_signal(SIGTERM, dummy_signal_handler);
/* Watch for any messages from the parent over the POD */
while (1) {
- rv = ap_mpm_pod_check(pod);
+ rv = ap_worker_pod_check(pod);
if (rv == AP_NORESTART) {
/* see if termination was triggered while we slept */
switch(terminate_mode) {
{
int pid;
- if (slot + 1 > ap_max_daemons_limit) {
- ap_max_daemons_limit = slot + 1;
+ if (slot + 1 > max_daemons_limit) {
+ max_daemons_limit = slot + 1;
}
if (one_process) {
for (i = 0; i < ap_daemons_limit; ++i) {
/* Initialization to satisfy the compiler. It doesn't know
- * that ap_threads_per_child is always > 0 */
+ * 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;
- if (i >= ap_max_daemons_limit && totally_free_length == idle_spawn_rate)
+ if (i >= max_daemons_limit && totally_free_length == idle_spawn_rate)
/* short cut if all active processes have been examined and
* enough empty scoreboard slots have been found
*/
break;
ps = &ap_scoreboard_image->parent[i];
- for (j = 0; j < ap_threads_per_child; j++) {
+ for (j = 0; j < threads_per_child; j++) {
ws = &ap_scoreboard_image->servers[i][j];
status = ws->status;
loop if no pid? not much else matters */
if (status <= SERVER_READY &&
!ps->quiescing &&
- ps->generation == ap_my_generation) {
+ ps->generation == my_generation) {
++idle_thread_count;
}
if (status >= SERVER_READY && status < SERVER_GRACEFUL) {
}
}
- ap_max_daemons_limit = last_non_dead + 1;
+ max_daemons_limit = last_non_dead + 1;
if (idle_thread_count > max_spare_threads) {
/* Kill off one child */
- ap_mpm_pod_signal(pod, TRUE);
+ ap_worker_pod_signal(pod, TRUE);
idle_spawn_rate = 1;
}
else if (idle_thread_count < min_spare_threads) {
/* terminate the free list */
if (free_length == 0) { /* scoreboard is full, can't fork */
- if (active_thread_count >= ap_daemons_limit * ap_threads_per_child) {
+ if (active_thread_count >= ap_daemons_limit * threads_per_child) {
static int reported = 0;
if (!reported) {
/* only report this condition once */
/* non-fatal death... note that it's gone in the scoreboard. */
child_slot = ap_find_child_by_pid(&pid);
if (child_slot >= 0) {
- for (i = 0; i < ap_threads_per_child; i++)
+ for (i = 0; i < threads_per_child; i++)
ap_update_child_status_from_indexes(child_slot, i, SERVER_DEAD,
(request_rec *) NULL);
}
}
-int ap_mpm_run(apr_pool_t *_pconf, apr_pool_t *plog, server_rec *s)
+static int worker_run(apr_pool_t *_pconf, apr_pool_t *plog, server_rec *s)
{
int remaining_children_to_start;
apr_status_t rv;
/* fix the generation number in the global score; we just got a new,
* cleared scoreboard
*/
- ap_scoreboard_image->global->running_generation = ap_my_generation;
+ ap_scoreboard_image->global->running_generation = my_generation;
}
set_signals();
/* Don't thrash... */
- if (max_spare_threads < min_spare_threads + ap_threads_per_child)
- max_spare_threads = min_spare_threads + ap_threads_per_child;
+ if (max_spare_threads < min_spare_threads + threads_per_child)
+ max_spare_threads = min_spare_threads + threads_per_child;
/* 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
/* Time to shut down:
* Kill child processes, tell them to call child_exit, etc...
*/
- ap_mpm_pod_killpg(pod, ap_daemons_limit, FALSE);
+ ap_worker_pod_killpg(pod, ap_daemons_limit, FALSE);
ap_reclaim_child_processes(1); /* Start with SIGTERM */
if (!child_fatal) {
/* Close our listeners, and then ask our children to do same */
ap_close_listeners();
- ap_mpm_pod_killpg(pod, ap_daemons_limit, TRUE);
+ ap_worker_pod_killpg(pod, ap_daemons_limit, TRUE);
ap_relieve_child_processes();
if (!child_fatal) {
* way, try and make sure that all of our processes are
* really dead.
*/
- ap_mpm_pod_killpg(pod, ap_daemons_limit, FALSE);
+ ap_worker_pod_killpg(pod, ap_daemons_limit, FALSE);
ap_reclaim_child_processes(1);
return 1;
/* XXX: we really need to make sure this new generation number isn't in
* use by any of the children.
*/
- ++ap_my_generation;
- ap_scoreboard_image->global->running_generation = ap_my_generation;
+ ++my_generation;
+ ap_scoreboard_image->global->running_generation = my_generation;
if (is_graceful) {
ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, ap_server_conf,
AP_SIG_GRACEFUL_STRING " received. Doing graceful restart");
/* wake up the children...time to die. But we'll have more soon */
- ap_mpm_pod_killpg(pod, ap_daemons_limit, TRUE);
+ ap_worker_pod_killpg(pod, ap_daemons_limit, TRUE);
/* This is mostly for debugging... so that we know what is still
* and a SIGHUP, we may as well use the same signal, because some user
* pthreads are stealing signals from us left and right.
*/
- ap_mpm_pod_killpg(pod, ap_daemons_limit, FALSE);
+ ap_worker_pod_killpg(pod, ap_daemons_limit, FALSE);
ap_reclaim_child_processes(1); /* Start with SIGTERM */
ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, ap_server_conf,
apr_status_t rv;
pconf = p;
- ap_server_conf = s;
/* the reverse of pre_config, we want this only the first time around */
if (restart_num++ == 0) {
}
if (!one_process) {
- if ((rv = ap_mpm_pod_open(pconf, &pod))) {
+ if ((rv = ap_worker_pod_open(pconf, &pod))) {
ap_log_error(APLOG_MARK, APLOG_CRIT | level_flags, rv,
(startup ? NULL : s),
"could not open pipe-of-death");
server_limit = DEFAULT_SERVER_LIMIT;
thread_limit = DEFAULT_THREAD_LIMIT;
ap_daemons_limit = server_limit;
- ap_threads_per_child = DEFAULT_THREADS_PER_CHILD;
- max_clients = ap_daemons_limit * ap_threads_per_child;
+ threads_per_child = DEFAULT_THREADS_PER_CHILD;
+ max_clients = ap_daemons_limit * threads_per_child;
ap_pid_fname = DEFAULT_PIDLOG;
ap_lock_fname = DEFAULT_LOCKFILE;
ap_max_requests_per_child = DEFAULT_MAX_REQUESTS_PER_CHILD;
thread_limit = first_thread_limit;
}
- if (ap_threads_per_child > thread_limit) {
+ if (threads_per_child > thread_limit) {
if (startup) {
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
"WARNING: ThreadsPerChild of %d exceeds ThreadLimit "
- "of", ap_threads_per_child);
+ "of", threads_per_child);
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
" %d threads, decreasing to %d.",
thread_limit, thread_limit);
ap_log_error(APLOG_MARK, APLOG_WARNING, 0, s,
"ThreadsPerChild of %d exceeds ThreadLimit "
"of %d, decreasing to match",
- ap_threads_per_child, thread_limit);
+ threads_per_child, thread_limit);
}
- ap_threads_per_child = thread_limit;
+ threads_per_child = thread_limit;
}
- else if (ap_threads_per_child < 1) {
+ else if (threads_per_child < 1) {
if (startup) {
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
"WARNING: ThreadsPerChild of %d not allowed, "
- "increasing to 1.", ap_threads_per_child);
+ "increasing to 1.", threads_per_child);
} else {
ap_log_error(APLOG_MARK, APLOG_WARNING, 0, s,
"ThreadsPerChild of %d not allowed, increasing to 1",
- ap_threads_per_child);
+ threads_per_child);
}
- ap_threads_per_child = 1;
+ threads_per_child = 1;
}
- if (max_clients < ap_threads_per_child) {
+ if (max_clients < threads_per_child) {
if (startup) {
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
"WARNING: MaxClients of %d is less than "
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
" %d, increasing to %d. MaxClients must be at "
"least as large",
- ap_threads_per_child, ap_threads_per_child);
+ 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 "
"of %d, increasing to match",
- max_clients, ap_threads_per_child);
+ max_clients, threads_per_child);
}
- max_clients = ap_threads_per_child;
+ max_clients = threads_per_child;
}
- ap_daemons_limit = max_clients / ap_threads_per_child;
+ ap_daemons_limit = max_clients / threads_per_child;
- if (max_clients % ap_threads_per_child) {
- int tmp_max_clients = ap_daemons_limit * ap_threads_per_child;
+ if (max_clients % threads_per_child) {
+ int tmp_max_clients = ap_daemons_limit * threads_per_child;
if (startup) {
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
"multiple of", max_clients);
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
" ThreadsPerChild of %d, decreasing to nearest "
- "multiple %d,", ap_threads_per_child,
+ "multiple %d,", threads_per_child,
tmp_max_clients);
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
" for a maximum of %d servers.",
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, ap_threads_per_child,
+ "multiple %d", max_clients, threads_per_child,
tmp_max_clients);
}
max_clients = tmp_max_clients;
"servers and ", max_clients, 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 * ap_threads_per_child);
+ server_limit, server_limit * threads_per_child);
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
" To increase, please see the ServerLimit "
"directive.");
"MaxClients of %d would require %d servers and "
"exceed ServerLimit of %d, decreasing to %d",
max_clients, ap_daemons_limit, server_limit,
- server_limit * ap_threads_per_child);
+ server_limit * threads_per_child);
}
ap_daemons_limit = server_limit;
}
- /* ap_daemons_to_start > ap_daemons_limit checked in ap_mpm_run() */
+ /* ap_daemons_to_start > ap_daemons_limit checked in worker_run() */
if (ap_daemons_to_start < 0) {
if (startup) {
ap_log_error(APLOG_MARK, APLOG_WARNING | APLOG_STARTUP, 0, NULL,
min_spare_threads = 1;
}
- /* max_spare_threads < min_spare_threads + ap_threads_per_child
- * checked in ap_mpm_run()
+ /* max_spare_threads < min_spare_threads + threads_per_child
+ * checked in worker_run()
*/
return OK;
*/
ap_hook_pre_config(worker_pre_config, NULL, NULL, APR_HOOK_REALLY_FIRST);
ap_hook_check_config(worker_check_config, NULL, NULL, APR_HOOK_MIDDLE);
+ ap_hook_mpm(worker_run, NULL, NULL, APR_HOOK_MIDDLE);
+ ap_hook_mpm_query(worker_query, NULL, NULL, APR_HOOK_MIDDLE);
+ ap_hook_mpm_get_child_pid(worker_get_child_pid, NULL, NULL, APR_HOOK_MIDDLE);
+ ap_hook_mpm_note_child_killed(worker_note_child_killed, NULL, NULL, APR_HOOK_MIDDLE);
}
static const char *set_daemons_to_start(cmd_parms *cmd, void *dummy,
return err;
}
- ap_threads_per_child = atoi(arg);
+ threads_per_child = atoi(arg);
return NULL;
}
#include "http_config.h"
#include "http_log.h"
#include "http_main.h"
-#include "mpm.h"
#include "mpm_common.h"
#include "ap_mpm.h"
#include "ap_listen.h"
-#include "mpm_default.h"
#include "util_mutex.h"
-#ifdef AP_MPM_WANT_SET_SCOREBOARD
+#ifndef AP_MPM_NO_SET_SCOREBOARD
#include "scoreboard.h"
#endif
APR_HOOK_LINK(fatal_exception)
APR_HOOK_LINK(monitor)
APR_HOOK_LINK(drop_privileges)
+ APR_HOOK_LINK(mpm)
+ APR_HOOK_LINK(mpm_query)
+ APR_HOOK_LINK(mpm_get_child_pid)
+ APR_HOOK_LINK(mpm_note_child_killed)
+ APR_HOOK_LINK(mpm_register_timed_callback)
)
AP_IMPLEMENT_HOOK_RUN_ALL(int, fatal_exception,
(ap_exception_info_t *ei), (ei), OK, DECLINED)
APR_HOOK_STRUCT(
APR_HOOK_LINK(monitor)
APR_HOOK_LINK(drop_privileges)
+ APR_HOOK_LINK(mpm)
+ APR_HOOK_LINK(mpm_query)
+ APR_HOOK_LINK(mpm_get_child_pid)
+ APR_HOOK_LINK(mpm_note_child_killed)
+ APR_HOOK_LINK(mpm_register_timed_callback)
)
#endif
AP_IMPLEMENT_HOOK_RUN_ALL(int, monitor,
AP_IMPLEMENT_HOOK_RUN_ALL(int, drop_privileges,
(apr_pool_t * pchild, server_rec * s),
(pchild, s), OK, DECLINED)
+AP_IMPLEMENT_HOOK_RUN_FIRST(int, mpm,
+ (apr_pool_t *pconf, apr_pool_t *plog, server_rec *s),
+ (pconf, plog, s), DECLINED)
+AP_IMPLEMENT_HOOK_RUN_FIRST(apr_status_t, mpm_query,
+ (int query_code, int *result),
+ (query_code, result), APR_ENOTIMPL)
+AP_IMPLEMENT_HOOK_RUN_FIRST(pid_t, mpm_get_child_pid,
+ (int childnum),
+ (childnum), 0)
+AP_IMPLEMENT_HOOK_RUN_FIRST(apr_status_t, mpm_note_child_killed,
+ (int childnum),
+ (childnum), APR_ENOTIMPL)
+AP_IMPLEMENT_HOOK_RUN_FIRST(apr_status_t, mpm_register_timed_callback,
+ (apr_time_t t, ap_mpm_callback_fn_t *cbfn, void *baton),
+ (t, cbfn, baton), APR_ENOTIMPL)
+
+/* XXX
+ * need better concept for controlling generation of MPM helper functions
+ * Unix MPMs don't have/need mpm.h; currently we rely on non-Unix MPMs providing that file
+ * with AP_MPM_NO_xxx defined for functions that won't work or won't be needed
+ * mpm_common.h has the #if HACK #include "mpm.h"
+ */
-
-#ifdef AP_MPM_WANT_RECLAIM_CHILD_PROCESSES
+#ifndef AP_MPM_NO_RECLAIM_CHILD_PROCESSES
typedef enum {DO_NOTHING, SEND_SIGTERM, SEND_SIGKILL, GIVEUP} action_t;
proc.pid = pid;
waitret = apr_proc_wait(&proc, &status, &why, APR_NOWAIT);
if (waitret != APR_CHILD_NOTDONE) {
-#ifdef AP_MPM_WANT_PROCESS_CHILD_STATUS
+#ifndef AP_MPM_NO_PROCESS_CHILD_STATUS
if (waitret == APR_CHILD_DONE)
ap_process_child_status(&proc, why, status);
#endif
/* now see who is done */
not_dead_yet = 0;
for (i = 0; i < max_daemons; ++i) {
- pid_t pid = MPM_CHILD_PID(i);
+ pid_t pid = ap_mpm_get_child_pid(i);
if (pid == 0) {
continue; /* not every scoreboard entry is in use */
}
if (reclaim_one_pid(pid, action_table[cur_action].action)) {
- MPM_NOTE_CHILD_KILLED(i);
+ ap_mpm_note_child_killed(i);
}
else {
++not_dead_yet;
/* now see who is done */
for (i = 0; i < max_daemons; ++i) {
- pid_t pid = MPM_CHILD_PID(i);
+ pid_t pid = ap_mpm_get_child_pid(i);
if (pid == 0) {
continue; /* not every scoreboard entry is in use */
}
if (reclaim_one_pid(pid, DO_NOTHING)) {
- MPM_NOTE_CHILD_KILLED(i);
+ ap_mpm_note_child_killed(i);
}
}
proc.pid = pid;
rv = apr_proc_wait(&proc, &status, &why, APR_NOWAIT);
if (rv == APR_CHILD_DONE) {
-#ifdef AP_MPM_WANT_PROCESS_CHILD_STATUS
+#ifndef AP_MPM_NO_PROCESS_CHILD_STATUS
/* The child already died - log the termination status if
* necessary: */
ap_process_child_status(&proc, why, status);
return kill(pid, sig) ? errno : APR_SUCCESS;
}
-#endif /* AP_MPM_WANT_RECLAIM_CHILD_PROCESSES */
+#endif /* AP_MPM_NO_RECLAIM_CHILD_PROCESSES */
-#ifdef AP_MPM_WANT_WAIT_OR_TIMEOUT
+#ifndef AP_MPM_NO_WAIT_OR_TIMEOUT
/* number of calls to wait_or_timeout between writable probes */
#ifndef INTERVAL_OF_WRITABLE_PROBES
return;
}
- apr_sleep(SCOREBOARD_MAINTENANCE_INTERVAL);
+ apr_sleep(1000000);
ret->pid = -1;
return;
}
-#endif /* AP_MPM_WANT_WAIT_OR_TIMEOUT */
+#endif /* AP_MPM_NO_WAIT_OR_TIMEOUT */
-#ifdef AP_MPM_WANT_PROCESS_CHILD_STATUS
+#ifndef AP_MPM_NO_PROCESS_CHILD_STATUS
int ap_process_child_status(apr_proc_t *pid, apr_exit_why_e why, int status)
{
int signum = status;
}
return 0;
}
-#endif /* AP_MPM_WANT_PROCESS_CHILD_STATUS */
+#endif /* AP_MPM_NO_PROCESS_CHILD_STATUS */
#if defined(TCP_NODELAY) && !defined(MPE) && !defined(TPF)
void ap_sock_disable_nagle(apr_socket_t *s)
}
#endif /* def NEED_INITGROUPS */
-#ifdef AP_MPM_USES_POD
+#ifndef AP_MPM_NO_POD
AP_DECLARE(apr_status_t) ap_mpm_pod_open(apr_pool_t *p, ap_pod_t **pod)
{
#endif /* #ifdef AP_MPM_USES_POD */
/* standard mpm configuration handling */
-#ifdef AP_MPM_WANT_SET_PIDFILE
+#ifndef AP_MPM_NO_SET_PIDFILE
const char *ap_pid_fname = NULL;
const char *ap_mpm_set_pidfile(cmd_parms *cmd, void *dummy,
}
#endif
-#ifdef AP_MPM_WANT_SET_SCOREBOARD
+#ifndef AP_MPM_NO_SET_SCOREBOARD
const char * ap_mpm_set_scoreboard(cmd_parms *cmd, void *dummy,
const char *arg)
{
}
#endif
-#ifdef AP_MPM_WANT_SET_LOCKFILE
+#ifndef AP_MPM_NO_SET_LOCKFILE
const char *ap_lock_fname = NULL;
const char *ap_mpm_set_lockfile(cmd_parms *cmd, void *dummy,
}
#endif
-#ifdef AP_MPM_WANT_SET_MAX_REQUESTS
+#ifndef AP_MPM_NO_SET_MAX_REQUESTS
int ap_max_requests_per_child = 0;
const char *ap_mpm_set_max_requests(cmd_parms *cmd, void *dummy,
}
#endif
-#ifdef AP_MPM_WANT_SET_COREDUMPDIR
+#ifndef AP_MPM_NO_SET_COREDUMPDIR
char ap_coredump_dir[MAX_STRING_LEN];
int ap_coredumpdir_configured;
}
#endif
-#ifdef AP_MPM_WANT_SET_GRACEFUL_SHUTDOWN
+#ifndef AP_MPM_NO_SET_GRACEFUL_SHUTDOWN
int ap_graceful_shutdown_timeout = 0;
const char * ap_mpm_set_graceful_shutdown(cmd_parms *cmd, void *dummy,
}
#endif
-#ifdef AP_MPM_WANT_SET_ACCEPT_LOCK_MECH
+#ifndef AP_MPM_NO_SET_ACCEPT_LOCK_MECH
apr_lockmech_e ap_accept_lock_mech = APR_LOCK_DEFAULT;
AP_DECLARE(const char *) ap_mpm_set_accept_lock_mech(cmd_parms *cmd,
#endif
-#ifdef AP_MPM_WANT_SIGNAL_SERVER
+#ifndef AP_MPM_NO_SIGNAL_SERVER
static const char *dash_k_arg;
}
if (!strcmp(dash_k_arg, "graceful-stop")) {
-#ifdef AP_MPM_WANT_SET_GRACEFUL_SHUTDOWN
+#ifndef AP_MPM_NO_SET_GRACEFUL_SHUTDOWN
if (!running) {
printf("%s\n", status);
}
}
}
-#endif /* AP_MPM_WANT_SIGNAL_SERVER */
+#endif /* AP_MPM_NO_SIGNAL_SERVER */
-#ifdef AP_MPM_WANT_SET_MAX_MEM_FREE
+#ifndef AP_MPM_NO_SET_MAX_MEM_FREE
apr_uint32_t ap_max_mem_free = APR_ALLOCATOR_MAX_FREE_UNLIMITED;
const char *ap_mpm_set_max_mem_free(cmd_parms *cmd, void *dummy,
return NULL;
}
-#endif /* AP_MPM_WANT_SET_MAX_MEM_FREE */
+#endif /* AP_MPM_NO_SET_MAX_MEM_FREE */
-#ifdef AP_MPM_WANT_SET_STACKSIZE
+#ifndef AP_MPM_NO_SET_STACKSIZE
apr_size_t ap_thread_stacksize = 0; /* use system default */
const char *ap_mpm_set_thread_stacksize(cmd_parms *cmd, void *dummy,
return NULL;
}
-#endif /* AP_MPM_WANT_SET_STACKSIZE */
+#endif /* AP_MPM_NO_SET_STACKSIZE */
-#ifdef AP_MPM_WANT_FATAL_SIGNAL_HANDLER
+#ifndef AP_MPM_NO_FATAL_SIGNAL_HANDLER
static pid_t parent_pid, my_pid;
static apr_pool_t *pconf;
return APR_SUCCESS;
}
-#endif /* AP_MPM_WANT_FATAL_SIGNAL_HANDLER */
+#endif /* AP_MPM_NO_FATAL_SIGNAL_HANDLER */
+
+AP_DECLARE(int) ap_mpm_run(apr_pool_t *pconf, apr_pool_t *plog, server_rec *server_conf)
+{
+ return ap_run_mpm(pconf, plog, server_conf);
+}
-#ifndef AP_MPM_HAS_USER_CALLBACKS
+AP_DECLARE(apr_status_t) ap_mpm_query(int query_code, int *result)
+{
+ return ap_run_mpm_query(query_code, result);
+}
-AP_DECLARE(void) ap_mpm_register_timed_callback(apr_time_t t,
- ap_mpm_callback_fn_t *cbfn,
- void *baton)
+AP_DECLARE(pid_t) ap_mpm_get_child_pid(int childnum)
{
- abort();
+ return ap_run_mpm_get_child_pid(childnum);
}
-#endif /* AP_MPM_HAS_USER_CALLBACKS */
+AP_DECLARE(apr_status_t) ap_mpm_note_child_killed(int childnum)
+{
+ return ap_run_mpm_note_child_killed(childnum);
+}
+
+AP_DECLARE(apr_status_t) ap_mpm_register_timed_callback(apr_time_t t, ap_mpm_callback_fn_t *cbfn, void *baton)
+{
+ return ap_run_mpm_register_timed_callback(t, cbfn, baton);
+}
+
+AP_DECLARE(const char *)ap_show_mpm(void)
+{
+ /* XXX hook this */
+ return "(unknown)";
+}
#include "http_config.h"
#include "ap_mpm.h"
-#include "mpm.h"
#include "scoreboard.h"
AP_DECLARE_DATA scoreboard *ap_scoreboard_image = NULL;
int old_status;
worker_score *ws;
process_score *ps;
+ int mpm_generation;
if (child_num < 0) {
return -1;
if (status == SERVER_READY
&& old_status == SERVER_STARTING) {
ws->thread_num = child_num * thread_limit + thread_num;
- ps->generation = ap_my_generation;
+ ap_mpm_query(AP_MPMQ_GENERATION, &mpm_generation);
+ ps->generation = mpm_generation;
}
if (ap_extended_status) {
projects / apache / commitdiff