child.c revision 9e12bb8a48225fc58bc56166b1104158e0d17ed4
/* ====================================================================
* The Apache Software License, Version 1.1
*
* Copyright (c) 2000-2002 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Apache" and "Apache Software Foundation" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* nor may "Apache" appear in their name, without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
*
* Portions of this software are based upon public domain software
* originally written at the National Center for Supercomputing Applications,
* University of Illinois, Urbana-Champaign.
*/
#ifdef WIN32
#define CORE_PRIVATE
#include "httpd.h"
#include "http_main.h"
#include "http_log.h"
#include "http_config.h" /* for read_config */
#include "http_core.h" /* for get_remote_host */
#include "http_connection.h"
#include "apr_portable.h"
#include "apr_thread_proc.h"
#include "apr_getopt.h"
#include "apr_strings.h"
#include "apr_lib.h"
#include "apr_shm.h"
#include "apr_thread_mutex.h"
#include "ap_mpm.h"
#include "ap_config.h"
#include "ap_listen.h"
#include "mpm_default.h"
#include "mpm_winnt.h"
#include "mpm_common.h"
#include <malloc.h>
#include "apr_atomic.h"
/* shared with mpm_winnt.c */
extern apr_pool_t *pconf;
/* used by parent to signal the child to start and exit */
/* shared with mpm_winnt.c, but should be private to child.c */
/* child_main() should never need to modify is_graceful!?! */
extern int volatile is_graceful;
/* Queue for managing the passing of COMP_CONTEXTs between
* the accept and worker threads.
*/
static int shutdown_in_progress = 0;
static int workers_may_exit = 0;
static unsigned int g_blocked_threads = 0;
static HANDLE max_requests_per_child_event;
static apr_thread_mutex_t *qlock;
static int num_completion_contexts = 0;
{
/* Recycle the completion context.
* - clear the ptrans pool
* - put the context on the queue to be consumed by the accept thread
* Note:
* context->accept_socket may be in a disconnected but reusable
* state so -don't- close it.
*/
if (context) {
if (qtail)
else
}
}
{
/* Grab a context off the queue */
if (qhead) {
if (!qhead)
}
/* If we failed to grab a context off the queue, alloc one out of
* the child pool. There may be up to ap_threads_per_child contexts
* in the system at once.
*/
if (!context) {
if (num_completion_contexts >= ap_threads_per_child) {
static int reported = 0;
if (!reported) {
"Server ran out of threads to serve requests. Consider "
"raising the ThreadsPerChild setting");
reported = 1;
}
return NULL;
}
/* Note:
* Multiple failures in the next two steps will cause the pchild pool
* to 'leak' storage. I don't think this is worth fixing...
*/
/* Hopefully this is a temporary condition ... */
"mpm_get_completion_context: CreateEvent failed.");
return NULL;
}
/* Create the tranaction pool */
"mpm_get_completion_context: Failed to create the transaction pool.");
return NULL;
}
}
return context;
}
{
if (context)
else
pOverlapped = NULL;
return APR_SUCCESS;
}
/*
* find_ready_listener()
* Only used by Win9* and should go away when the win9*_accept() function is
* reimplemented using apr_poll().
*/
static ap_listen_rec *head_listener;
{
if (head_listener == NULL)
return (lr);
}
}
return NULL;
}
/* Windows 9x specific code...
* model. A single thread accepts connections and queues the accepted socket
* to the accept queue for consumption by a pool of worker threads.
*
* win9x_accept()
* The accept threads runs this function, which accepts connections off
* the network and calls add_job() to queue jobs to the accept_queue.
* add_job()/remove_job()
* Add or remove an accepted socket from the list of sockets
* connected to clients. allowed_globals.jobmutex protects
* against multiple concurrent access to the linked list of jobs.
* win9x_get_connection()
* Calls remove_job() to pull a job from the accept queue. All the worker
* threads block on remove_job.
*/
typedef struct joblist_s {
int sock;
} joblist;
typedef struct globals_s {
int jobcount;
} globals;
#define MAX_SELECT_ERRORS 100
{
"Ouch! Out of memory in add_job()!");
return;
}
if (!allowed_globals.jobhead)
}
static int remove_job(void)
{
int sock;
return (-1);
}
return (sock);
}
static void win9x_accept(void * dummy)
{
int wait_time = 1;
int csd;
struct sockaddr_in sa_client;
int count_select_errors = 0;
int rc;
int clen;
/* Setup the listeners
* ToDo: Use apr_poll()
*/
listenmaxfd = nsd;
}
}
}
while (!shutdown_in_progress) {
count_select_errors = 0; /* reset count of errors */
continue;
}
else if (rc == SOCKET_ERROR) {
/* A "real" error occurred, log it and increment the count of
* select errors. This count is used to ensure we don't go into
* a busy loop of continuous errors.
*/
"select failed with error %d", apr_get_netos_error());
if (count_select_errors > MAX_SELECT_ERRORS) {
shutdown_in_progress = 1;
"Too many errors in select loop. Child process exiting.");
break;
}
} else {
/* fetch the native socket descriptor */
}
}
do {
if (csd == INVALID_SOCKET) {
csd = -1;
}
if (csd < 0) {
"accept: (client socket)");
}
}
else {
}
}
}
{
int len;
/* allocate the completion context and the transaction pool */
}
while (1) {
return NULL;
}
"getsockname failed");
continue;
}
"getpeername failed");
}
return context;
}
}
/* Windows NT/2000 specific code...
* model. An accept thread accepts connections off the network then issues
* PostQueuedCompletionStatus() to awake a thread blocked on the ThreadDispatch
* IOCompletionPort.
*
* winnt_accept()
* One or more accept threads run in this function, each of which accepts
* connections off the network and calls PostQueuedCompletionStatus() to
* queue an io completion packet to the ThreadDispatch IOCompletionPort.
* winnt_get_connection()
* Worker threads block on the ThreadDispatch IOCompletionPort awaiting
* connections to service.
*/
static void winnt_accept(void *lr_)
{
int rv;
while (!shutdown_in_progress) {
if (!context) {
if (!context) {
/* Temporary resource constraint? */
Sleep(0);
continue;
}
}
/* Create and initialize the accept socket */
/* Another temporary condition? */
"winnt_accept: Failed to allocate an accept socket. "
"Temporary resource constraint? Try again.");
Sleep(100);
continue;
}
}
/* AcceptEx on the completion context. The completion context will be
* signaled when a connection is accepted.
*/
0,
&context->Overlapped)) {
rv = apr_get_netos_error();
/* Hack alert. Occasionally, TransmitFile will not recycle the
* accept socket (usually when the client disconnects early).
* Get a new socket and try the call again.
*/
"winnt_accept: AcceptEx failed due to early client "
"disconnect. Reallocate the accept socket and try again.");
continue;
}
"winnt_accept: AcceptEx failed. Attempting to recover.");
Sleep(100);
continue;
}
/* Wait for pending i/o. Wake up once per second to check for shutdown */
while (1) {
if (rv == WAIT_OBJECT_0) {
"winnt_accept: Asynchronous AcceptEx failed.");
}
break;
}
/* WAIT_TIMEOUT */
if (shutdown_in_progress) {
break;
}
}
continue;
}
}
/* Inherit the listen socket settings. Required for
* shutdown() to work
*/
SO_UPDATE_ACCEPT_CONTEXT, (char *)&nlsd,
sizeof(nlsd))) {
"setsockopt(SO_UPDATE_ACCEPT_CONTEXT) failed.");
/* Not a failure condition. Keep running. */
}
/* Get the local & remote address */
0,
&context->sa_client_len);
/* When a connection is received, send an io completion notification to
* the ThreadDispatchIOCP. This function could be replaced by
* mpm_post_completion_context(), but why do an extra function call...
*/
&context->Overlapped);
}
if (!shutdown_in_progress) {
/* Yow, hit an irrecoverable error! Tell the child to die. */
}
"Child %d: Accept thread exiting.", my_pid);
}
{
int rc;
while (1) {
if (workers_may_exit) {
return NULL;
}
if (!rc) {
rc = apr_get_os_error();
continue;
}
switch (CompKey) {
case IOCP_CONNECTION_ACCEPTED:
break;
case IOCP_SHUTDOWN:
return NULL;
default:
return NULL;
}
break;
}
return context;
}
/*
* worker_main()
* Main entry point for the worker threads. Worker threads block in
* win*_get_connection() awaiting a connection to service.
*/
static void worker_main(long thread_num)
{
static int requests_this_child = 0;
while (1) {
conn_rec *c;
/* Grab a connection off the network */
}
else {
}
if (!context) {
/* Time for the thread to exit */
break;
}
/* Have we hit MaxRequestPerChild connections? */
if (ap_max_requests_per_child) {
}
}
if (c) {
&disconnected);
if (!disconnected) {
}
}
else {
/* ap_run_create_connection closes the socket on failure */
}
}
(request_rec *) NULL);
}
{
int i;
(*thread_cnt)--;
}
/*
* child_main()
* Entry point for the main control thread for the child process.
* This thread creates the accept thread, worker threads and
* monitors the child process for maintenance and shutdown
* events.
*/
static void create_listener_thread()
{
int tid;
} else {
/* Start an accept thread per listener
* XXX: Why would we have a NULL sd in our listeners?
*/
}
}
}
}
void child_main()
{
apr_hash_t *ht;
int threads_created = 0;
int listener_started = 0;
int tid;
int rv;
int i;
int cld;
/* Initialize the child_events */
if (!max_requests_per_child_event) {
"Child %d: Failed to create a max_requests event.", my_pid);
}
child_events[0] = exit_event;
/*
* Wait until we have permission to start accepting connections.
* start_mutex is used to ensure that only one child ever
*/
if (status != APR_SUCCESS) {
"Child %d: Failed to acquire the start_mutex. Process will exit.", my_pid);
}
"Child %d: Acquired the start mutex.", my_pid);
/*
* Create the worker thread dispatch IOCompletionPort
* on Windows NT/2000
*/
/* Create the worker thread dispatch IOCP */
NULL,
0,
0); /* CONCURRENT ACTIVE THREADS */
}
/*
* Create the pool of worker threads
*/
while (1) {
for (i = 0; i < ap_threads_per_child; i++) {
int *score_idx;
continue;
}
(void *) i, 0, &tid);
if (child_handles[i] == 0) {
"Child %d: _beginthreadex failed. Unable to create all worker threads. "
"Created %d of the %d threads requested with the ThreadsPerChild configuration directive.",
goto shutdown;
}
/* Save the score board index in ht keyed to the thread handle. We need this
* when cleaning up threads down below...
*/
*score_idx = i;
}
/* Start the listener only when workers are available */
if (!listener_started && threads_created) {
listener_started = 1;
}
if (threads_created == ap_threads_per_child) {
break;
}
/* Check to see if the child has been told to exit */
break;
}
/* wait for previous generation to clean up an entry in the scoreboard */
}
/* Wait for one of three events:
* exit_event:
* The exit_event is signaled by the parent process to notify
* the child that it is time to exit.
*
* max_requests_per_child_event:
* This event is signaled by the worker threads to indicate that
* the process has handled MaxRequestsPerChild connections.
*
* TIMEOUT:
* To do periodic maintenance on the server (check for thread exits,
* number of completion contexts, etc.)
*/
while (1) {
if (rv == WAIT_FAILED) {
/* Something serious is wrong */
"Child %d: WAIT_FAILED -- shutting down server");
break;
}
else if (rv == WAIT_TIMEOUT) {
}
else if (cld == 0) {
/* Exit event was signaled */
"Child %d: Exit event signaled. Child process is ending.", my_pid);
break;
}
else {
/* MaxRequestsPerChild event set by the worker threads.
* Signal the parent to restart
*/
"Child %d: Process exiting because it reached "
"MaxRequestsPerChild. Signaling the parent to "
"restart a new child process.", my_pid);
break;
}
}
/*
* Time to shutdown the child process
*/
/* Setting is_graceful will cause threads handling keep-alive connections
* to close the connection after handling the current request.
*/
is_graceful = 1;
/* Close the listening sockets. Note, we must close the listeners
* before closing any accept sockets pending in AcceptEx to prevent
* memory leaks in the kernel.
*/
}
/* Shutdown listener threads and pending AcceptEx socksts
* but allow the worker threads to continue consuming from
* the queue of accepted connections.
*/
shutdown_in_progress = 1;
Sleep(1000);
/* Tell the worker threads to exit */
workers_may_exit = 1;
/* Release the start_mutex to let the new process (in the restart
* scenario) a chance to begin accepting and servicing requests
*/
if (rv == APR_SUCCESS) {
"Child %d: Released the start mutex", my_pid);
}
else {
"Child %d: Failure releasing the start mutex", my_pid);
}
/* Shutdown the worker threads */
for (i = 0; i < threads_created; i++) {
add_job(-1);
}
}
else { /* Windows NT/2000 */
/* Post worker threads blocked on the ThreadDispatch IOCompletion port */
while (g_blocked_threads > 0) {
for (i=g_blocked_threads; i > 0; i--) {
}
Sleep(1000);
}
/* Empty the accept queue of completion contexts */
while (qhead) {
}
}
/* Give busy worker threads a chance to service their connections */
while (threads_created) {
if (rv != WAIT_TIMEOUT) {
continue;
}
break;
}
/* Kill remaining threads off the hard way */
if (threads_created) {
"Child %d: Terminating %d threads that failed to exit.", my_pid);
}
for (i = 0; i < threads_created; i++) {
int *score_idx;
CloseHandle(child_handles[i]);
/* Reset the scoreboard entry for the thread we just whacked */
}
"Child %d: All worker threads have exited.", my_pid);
}
#endif /* def WIN32 */