]> granicus.if.org Git - apache/commitdiff
the eight space tabs are harassing me.
authorAndré Malo <nd@apache.org>
Sun, 11 Apr 2004 23:55:10 +0000 (23:55 +0000)
committerAndré Malo <nd@apache.org>
Sun, 11 Apr 2004 23:55:10 +0000 (23:55 +0000)
:set tabstop=8
:retab
(no code changes)

git-svn-id: https://svn.apache.org/repos/asf/httpd/httpd/trunk@103348 13f79535-47bb-0310-9956-ffa450edef68

server/mpm/prefork/prefork.c

index 526c4f6a4639e354c635ae60f0e4199c3f47018b..3dbbe58fffb6c79bc2c4d1d69d17cb1c02623ac6 100644 (file)
@@ -38,7 +38,7 @@
 #include "http_main.h"
 #include "http_log.h"
 #include "http_config.h"
-#include "http_core.h"         /* for get_remote_host */
+#include "http_core.h"          /* for get_remote_host */
 #include "http_connection.h"
 #include "scoreboard.h"
 #include "ap_mpm.h"
@@ -49,7 +49,7 @@
 #include "apr_poll.h"
 
 #ifdef HAVE_BSTRING_H
-#include <bstring.h>           /* for IRIX, FD_SET calls bzero() */
+#include <bstring.h>            /* for IRIX, FD_SET calls bzero() */
 #endif
 #ifdef HAVE_TIME_H
 #include <time.h>
@@ -122,10 +122,10 @@ server_rec *ap_server_conf;
 
 static int one_process = 0;
 
-static apr_pool_t *pconf;              /* Pool for config stuff */
-static apr_pool_t *pchild;             /* Pool for httpd child stuff */
+static apr_pool_t *pconf;               /* Pool for config stuff */
+static apr_pool_t *pchild;              /* Pool for httpd child stuff */
 
-static pid_t ap_my_pid;        /* it seems silly to call getpid all the time */
+static pid_t ap_my_pid; /* it seems silly to call getpid all the time */
 static pid_t parent_pid;
 #ifndef MULTITHREAD
 static int my_child_num;
@@ -149,33 +149,33 @@ static int die_now = 0;
 static void chdir_for_gprof(void)
 {
     core_server_config *sconf = 
-       ap_get_module_config(ap_server_conf->module_config, &core_module);    
+        ap_get_module_config(ap_server_conf->module_config, &core_module); 
     char *dir = sconf->gprof_dir;
     const char *use_dir;
 
     if(dir) {
         apr_status_t res;
-       char buf[512];
-       int len = strlen(sconf->gprof_dir) - 1;
-       if(*(dir + len) == '%') {
-           dir[len] = '\0';
-           apr_snprintf(buf, sizeof(buf), "%sgprof.%d", dir, (int)getpid());
-       }
+        char buf[512];
+        int len = strlen(sconf->gprof_dir) - 1;
+        if(*(dir + len) == '%') {
+            dir[len] = '\0';
+            apr_snprintf(buf, sizeof(buf), "%sgprof.%d", dir, (int)getpid());
+        }
         else {
             buf[0] = '\0';
         }
-       use_dir = ap_server_root_relative(pconf, buf[0] ? buf : dir);
-       res = apr_dir_make(use_dir,
+        use_dir = ap_server_root_relative(pconf, buf[0] ? buf : dir);
+        res = apr_dir_make(use_dir,
                            APR_UREAD | APR_UWRITE | APR_UEXECUTE |
                            APR_GREAD | APR_GEXECUTE |
                            APR_WREAD | APR_WEXECUTE, pconf);
-       if(res != APR_SUCCESS && !APR_STATUS_IS_EEXIST(res)) {
-           ap_log_error(APLOG_MARK, APLOG_ERR, res, ap_server_conf,
-                        "gprof: error creating directory %s", dir);
-       }
+        if(res != APR_SUCCESS && !APR_STATUS_IS_EEXIST(res)) {
+            ap_log_error(APLOG_MARK, APLOG_ERR, res, ap_server_conf,
+                         "gprof: error creating directory %s", dir);
+        }
     }
     else {
-       use_dir = ap_server_root_relative(pconf, DEFAULT_REL_RUNTIMEDIR);
+        use_dir = ap_server_root_relative(pconf, DEFAULT_REL_RUNTIMEDIR);
     }
 
     chdir(use_dir);
@@ -195,7 +195,7 @@ static void clean_child_exit(int code)
     mpm_state = AP_MPMQ_STOPPING;
 
     if (pchild) {
-       apr_pool_destroy(pchild);
+        apr_pool_destroy(pchild);
     }
     ap_mpm_pod_close(pod);
     chdir_for_gprof();
@@ -255,45 +255,45 @@ static void accept_mutex_off(void)
 AP_DECLARE(apr_status_t) ap_mpm_query(int query_code, int *result)
 {
     switch(query_code){
-        case AP_MPMQ_MAX_DAEMON_USED:
-            *result = ap_daemons_limit;
-            return APR_SUCCESS;
-        case AP_MPMQ_IS_THREADED:
-            *result = AP_MPMQ_NOT_SUPPORTED;
-            return APR_SUCCESS;
-        case AP_MPMQ_IS_FORKED:
-            *result = AP_MPMQ_DYNAMIC;
-            return APR_SUCCESS;
-        case AP_MPMQ_HARD_LIMIT_DAEMONS:
-            *result = server_limit;
-            return APR_SUCCESS;
-        case AP_MPMQ_HARD_LIMIT_THREADS:
-            *result = HARD_THREAD_LIMIT;
-            return APR_SUCCESS;
-        case AP_MPMQ_MAX_THREADS:
-            *result = 0;
-            return APR_SUCCESS;
-        case AP_MPMQ_MIN_SPARE_DAEMONS:
-            *result = ap_daemons_min_free;
-            return APR_SUCCESS;
-        case AP_MPMQ_MIN_SPARE_THREADS:
-            *result = 0;
-            return APR_SUCCESS;
-        case AP_MPMQ_MAX_SPARE_DAEMONS:
-            *result = ap_daemons_max_free;
-            return APR_SUCCESS;
-        case AP_MPMQ_MAX_SPARE_THREADS:
-            *result = 0;
-            return APR_SUCCESS;
-        case AP_MPMQ_MAX_REQUESTS_DAEMON:
-            *result = ap_max_requests_per_child;
-            return APR_SUCCESS;
-        case AP_MPMQ_MAX_DAEMONS:
-            *result = server_limit;
-            return APR_SUCCESS;
-        case AP_MPMQ_MPM_STATE:
-            *result = mpm_state;
-            return APR_SUCCESS;
+    case AP_MPMQ_MAX_DAEMON_USED:
+        *result = ap_daemons_limit;
+        return APR_SUCCESS;
+    case AP_MPMQ_IS_THREADED:
+        *result = AP_MPMQ_NOT_SUPPORTED;
+        return APR_SUCCESS;
+    case AP_MPMQ_IS_FORKED:
+        *result = AP_MPMQ_DYNAMIC;
+        return APR_SUCCESS;
+    case AP_MPMQ_HARD_LIMIT_DAEMONS:
+        *result = server_limit;
+        return APR_SUCCESS;
+    case AP_MPMQ_HARD_LIMIT_THREADS:
+        *result = HARD_THREAD_LIMIT;
+        return APR_SUCCESS;
+    case AP_MPMQ_MAX_THREADS:
+        *result = 0;
+        return APR_SUCCESS;
+    case AP_MPMQ_MIN_SPARE_DAEMONS:
+        *result = ap_daemons_min_free;
+        return APR_SUCCESS;
+    case AP_MPMQ_MIN_SPARE_THREADS:
+        *result = 0;
+        return APR_SUCCESS;
+    case AP_MPMQ_MAX_SPARE_DAEMONS:
+        *result = ap_daemons_max_free;
+        return APR_SUCCESS;
+    case AP_MPMQ_MAX_SPARE_THREADS:
+        *result = 0;
+        return APR_SUCCESS;
+    case AP_MPMQ_MAX_REQUESTS_DAEMON:
+        *result = ap_max_requests_per_child;
+        return APR_SUCCESS;
+    case AP_MPMQ_MAX_DAEMONS:
+        *result = server_limit;
+        return APR_SUCCESS;
+    case AP_MPMQ_MPM_STATE:
+        *result = mpm_state;
+        return APR_SUCCESS;
     }
     return APR_ENOTIMPL;
 }
@@ -308,14 +308,14 @@ int reap_children(int *exitcode, apr_exit_why_e *status)
     int n, pid;
 
     for (n = 0; n < ap_max_daemons_limit; ++n) {
-       if (ap_scoreboard_image->servers[n][0].status != SERVER_DEAD &&
-               kill((pid = ap_scoreboard_image->parent[n].pid), 0) == -1) {
-           ap_update_child_status_from_indexes(n, 0, SERVER_DEAD, NULL);
-           /* just mark it as having a successful exit status */
+        if (ap_scoreboard_image->servers[n][0].status != SERVER_DEAD &&
+                kill((pid = ap_scoreboard_image->parent[n].pid), 0) == -1) {
+            ap_update_child_status_from_indexes(n, 0, SERVER_DEAD, NULL);
+            /* just mark it as having a successful exit status */
             *status = APR_PROC_EXIT;
             *exitcode = 0;
-           return(pid);
-       }
+            return(pid);
+        }
     }
     return 0;
 }
@@ -338,11 +338,11 @@ static int volatile is_graceful;
 static void sig_term(int sig)
 {
     if (shutdown_pending == 1) {
-       /* Um, is this _probably_ not an error, if the user has
-        * tried to do a shutdown twice quickly, so we won't
-        * worry about reporting it.
-        */
-       return;
+        /* Um, is this _probably_ not an error, if the user has
+         * tried to do a shutdown twice quickly, so we won't
+         * worry about reporting it.
+         */
+        return;
     }
     shutdown_pending = 1;
 }
@@ -353,8 +353,8 @@ static void sig_term(int sig)
 static void restart(int sig)
 {
     if (restart_pending == 1) {
-       /* Probably not an error - don't bother reporting it */
-       return;
+        /* Probably not an error - don't bother reporting it */
+        return;
     }
     restart_pending = 1;
     is_graceful = (sig == AP_SIG_GRACEFUL);
@@ -376,7 +376,7 @@ static void set_signals(void)
 
     sa.sa_handler = sig_term;
     if (sigaction(SIGTERM, &sa, NULL) < 0)
-       ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf, "sigaction(SIGTERM)");
+        ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf, "sigaction(SIGTERM)");
 #ifdef SIGINT
     if (sigaction(SIGINT, &sa, NULL) < 0)
         ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf, "sigaction(SIGINT)");
@@ -384,35 +384,36 @@ static void set_signals(void)
 #ifdef SIGXCPU
     sa.sa_handler = SIG_DFL;
     if (sigaction(SIGXCPU, &sa, NULL) < 0)
-       ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf, "sigaction(SIGXCPU)");
+        ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf, "sigaction(SIGXCPU)");
 #endif
 #ifdef SIGXFSZ
     sa.sa_handler = SIG_DFL;
     if (sigaction(SIGXFSZ, &sa, NULL) < 0)
-       ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf, "sigaction(SIGXFSZ)");
+        ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf, "sigaction(SIGXFSZ)");
 #endif
 #ifdef SIGPIPE
     sa.sa_handler = SIG_IGN;
     if (sigaction(SIGPIPE, &sa, NULL) < 0)
-       ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf, "sigaction(SIGPIPE)");
+        ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf, "sigaction(SIGPIPE)");
 #endif
 
     /* we want to ignore HUPs and AP_SIG_GRACEFUL while we're busy 
-     * processing one */
+     * processing one
+     */
     sigaddset(&sa.sa_mask, SIGHUP);
     sigaddset(&sa.sa_mask, AP_SIG_GRACEFUL);
     sa.sa_handler = restart;
     if (sigaction(SIGHUP, &sa, NULL) < 0)
-       ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf, "sigaction(SIGHUP)");
+        ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf, "sigaction(SIGHUP)");
     if (sigaction(AP_SIG_GRACEFUL, &sa, NULL) < 0)
         ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf, "sigaction(" AP_SIG_GRACEFUL_STRING ")");
 #else
     if (!one_process) {
 #ifdef SIGXCPU
-       apr_signal(SIGXCPU, SIG_DFL);
+        apr_signal(SIGXCPU, SIG_DFL);
 #endif /* SIGXCPU */
 #ifdef SIGXFSZ
-       apr_signal(SIGXFSZ, SIG_DFL);
+        apr_signal(SIGXFSZ, SIG_DFL);
 #endif /* SIGXFSZ */
     }
 
@@ -460,8 +461,8 @@ static void child_main(int child_num_arg)
     int last_poll_idx = 0;
 
     mpm_state = AP_MPMQ_STARTING; /* for benefit of any hooks that run as this
-                                  * child initializes
-                                  */
+                                   * child initializes
+                                   */
     
     my_child_num = child_num_arg;
     ap_my_pid = getpid();
@@ -491,7 +492,7 @@ static void child_main(int child_num_arg)
     }
 
     if (unixd_setup_child()) {
-       clean_child_exit(APEXIT_CHILDFATAL);
+        clean_child_exit(APEXIT_CHILDFATAL);
     }
 
     ap_run_child_init(pchild, ap_server_conf);
@@ -524,25 +525,25 @@ static void child_main(int child_num_arg)
         conn_rec *current_conn;
         void *csd;
 
-       /*
-        * (Re)initialize this child to a pre-connection state.
-        */
+        /*
+         * (Re)initialize this child to a pre-connection state.
+         */
 
-       apr_pool_clear(ptrans);
+        apr_pool_clear(ptrans);
 
-       if ((ap_max_requests_per_child > 0
-            && requests_this_child++ >= ap_max_requests_per_child)) {
-           clean_child_exit(0);
-       }
+        if ((ap_max_requests_per_child > 0
+             && requests_this_child++ >= ap_max_requests_per_child)) {
+            clean_child_exit(0);
+        }
 
-       (void) ap_update_child_status(sbh, SERVER_READY, (request_rec *) NULL);
+        (void) ap_update_child_status(sbh, SERVER_READY, (request_rec *) NULL);
 
-       /*
-        * Wait for an acceptable connection to arrive.
-        */
+        /*
+         * Wait for an acceptable connection to arrive.
+         */
 
-       /* Lock around "accept", if necessary */
-       SAFE_ACCEPT(accept_mutex_on());
+        /* Lock around "accept", if necessary */
+        SAFE_ACCEPT(accept_mutex_on());
 
         if (num_listensocks == 1) {
             /* There is only one listener record, so refer to that one. */
@@ -550,7 +551,7 @@ static void child_main(int child_num_arg)
         }
         else {
             /* multiple listening sockets - need to poll */
-           for (;;) {
+            for (;;) {
                 apr_int32_t numdesc;
                 const apr_pollfd_t *pdesc;
 
@@ -563,15 +564,15 @@ static void child_main(int child_num_arg)
                         }
                         continue;
                     }
-                   /* Single Unix documents select as returning errnos
-                    * EBADF, EINTR, and EINVAL... and in none of those
-                    * cases does it make sense to continue.  In fact
-                    * on Linux 2.0.x we seem to end up with EFAULT
-                    * occasionally, and we'd loop forever due to it.
-                    */
-                   ap_log_error(APLOG_MARK, APLOG_ERR, status,
+                    /* Single Unix documents select as returning errnos
+                     * EBADF, EINTR, and EINVAL... and in none of those
+                     * cases does it make sense to continue.  In fact
+                     * on Linux 2.0.x we seem to end up with EFAULT
+                     * occasionally, and we'd loop forever due to it.
+                     */
+                    ap_log_error(APLOG_MARK, APLOG_ERR, status,
                                  ap_server_conf, "apr_pollset_poll: (listen)");
-                   clean_child_exit(1);
+                    clean_child_exit(1);
                 }
 
                 /* We can always use pdesc[0], but sockets at position N
@@ -599,9 +600,9 @@ static void child_main(int child_num_arg)
             }
         }
     got_fd:
-       /* if we accept() something we don't want to die, so we have to
-        * defer the exit
-        */
+        /* if we accept() something we don't want to die, so we have to
+         * defer the exit
+         */
         status = lr->accept_func(&csd, lr, ptrans);
 
         SAFE_ACCEPT(accept_mutex_off());      /* unlock after "accept" */
@@ -614,12 +615,12 @@ static void child_main(int child_num_arg)
             continue;
         }
 
-       /*
-        * We now have a connection, so set it up with the appropriate
-        * socket options, file descriptors, and read/write buffers.
-        */
+        /*
+         * We now have a connection, so set it up with the appropriate
+         * socket options, file descriptors, and read/write buffers.
+         */
 
-       current_conn = ap_run_create_connection(ptrans, ap_server_conf, csd, my_child_num, sbh, bucket_alloc);
+        current_conn = ap_run_create_connection(ptrans, ap_server_conf, csd, my_child_num, sbh, bucket_alloc);
         if (current_conn) {
             ap_process_connection(current_conn, csd);
             ap_lingering_close(current_conn);
@@ -650,18 +651,18 @@ static int make_child(server_rec *s, int slot)
     int pid;
 
     if (slot + 1 > ap_max_daemons_limit) {
-       ap_max_daemons_limit = slot + 1;
+        ap_max_daemons_limit = slot + 1;
     }
 
     if (one_process) {
-       apr_signal(SIGHUP, sig_term);
+        apr_signal(SIGHUP, sig_term);
         /* Don't catch AP_SIG_GRACEFUL in ONE_PROCESS mode :) */
-       apr_signal(SIGINT, sig_term);
+        apr_signal(SIGINT, sig_term);
 #ifdef SIGQUIT
-       apr_signal(SIGQUIT, SIG_DFL);
+        apr_signal(SIGQUIT, SIG_DFL);
 #endif
-       apr_signal(SIGTERM, sig_term);
-       child_main(slot);
+        apr_signal(SIGTERM, sig_term);
+        child_main(slot);
         return 0;
     }
 
@@ -677,20 +678,21 @@ static int make_child(server_rec *s, int slot)
 #else
     if ((pid = fork()) == -1) {
 #endif
-       ap_log_error(APLOG_MARK, APLOG_ERR, errno, s, "fork: Unable to fork new process");
+        ap_log_error(APLOG_MARK, APLOG_ERR, errno, s, "fork: Unable to fork new process");
 
-       /* fork didn't succeed. Fix the scoreboard or else
-        * it will say SERVER_STARTING forever and ever
-        */
-       (void) ap_update_child_status_from_indexes(slot, 0, SERVER_DEAD,
+        /* fork didn't succeed. Fix the scoreboard or else
+         * it will say SERVER_STARTING forever and ever
+         */
+        (void) ap_update_child_status_from_indexes(slot, 0, SERVER_DEAD,
                                                    (request_rec *) NULL);
 
-       /* In case system resources are maxxed out, we don't want
-          Apache running away with the CPU trying to fork over and
-          over and over again. */
-       sleep(10);
+        /* In case system resources are maxxed out, we don't want
+         * Apache running away with the CPU trying to fork over and
+         * over and over again.
+         */
+        sleep(10);
 
-       return -1;
+        return -1;
     }
 
     if (!pid) {
@@ -698,25 +700,25 @@ static int make_child(server_rec *s, int slot)
         /* by default AIX binds to a single processor
          * this bit unbinds children which will then bind to another cpu
          */
-       int status = bindprocessor(BINDPROCESS, (int)getpid(), 
-                                  PROCESSOR_CLASS_ANY);
-       if (status != OK) {
-           ap_log_error(APLOG_MARK, APLOG_WARNING, errno, 
+        int status = bindprocessor(BINDPROCESS, (int)getpid(), 
+                                   PROCESSOR_CLASS_ANY);
+        if (status != OK) {
+            ap_log_error(APLOG_MARK, APLOG_WARNING, errno, 
                          ap_server_conf, "processor unbind failed %d", status);
-       }
+        }
 #endif
-       RAISE_SIGSTOP(MAKE_CHILD);
+        RAISE_SIGSTOP(MAKE_CHILD);
         AP_MONCONTROL(1);
         /* Disable the parent's signal handlers and set up proper handling in
          * the child.
-        */
-       apr_signal(SIGHUP, just_die);
-       apr_signal(SIGTERM, just_die);
+         */
+        apr_signal(SIGHUP, just_die);
+        apr_signal(SIGTERM, just_die);
         /* The child process doesn't do anything for AP_SIG_GRACEFUL.  
          * Instead, the pod is used for signalling graceful restart.
          */
         apr_signal(AP_SIG_GRACEFUL, SIG_IGN);
-       child_main(slot);
+        child_main(slot);
     }
 
     ap_scoreboard_image->parent[slot].pid = pid;
@@ -731,13 +733,13 @@ static void startup_children(int number_to_start)
     int i;
 
     for (i = 0; number_to_start && i < ap_daemons_limit; ++i) {
-       if (ap_scoreboard_image->servers[i][0].status != SERVER_DEAD) {
-           continue;
-       }
-       if (make_child(ap_server_conf, i) < 0) {
-           break;
-       }
-       --number_to_start;
+        if (ap_scoreboard_image->servers[i][0].status != SERVER_DEAD) {
+            continue;
+        }
+        if (make_child(ap_server_conf, i) < 0) {
+            break;
+        }
+        --number_to_start;
     }
 }
 
@@ -750,7 +752,7 @@ static void startup_children(int number_to_start)
  */
 static int idle_spawn_rate = 1;
 #ifndef MAX_SPAWN_RATE
-#define MAX_SPAWN_RATE (32)
+#define MAX_SPAWN_RATE  (32)
 #endif
 static int hold_off_on_exponential_spawning;
 
@@ -774,99 +776,99 @@ static void perform_idle_server_maintenance(apr_pool_t *p)
     total_non_dead = 0;
 
     for (i = 0; i < ap_daemons_limit; ++i) {
-       int status;
-
-       if (i >= ap_max_daemons_limit && free_length == idle_spawn_rate)
-           break;
-       ws = &ap_scoreboard_image->servers[i][0];
-       status = ws->status;
-       if (status == SERVER_DEAD) {
-           /* try to keep children numbers as low as possible */
-           if (free_length < idle_spawn_rate) {
-               free_slots[free_length] = i;
-               ++free_length;
-           }
-       }
-       else {
-           /* We consider a starting server as idle because we started it
-            * at least a cycle ago, and if it still hasn't finished starting
-            * then we're just going to swamp things worse by forking more.
-            * So we hopefully won't need to fork more if we count it.
-            * This depends on the ordering of SERVER_READY and SERVER_STARTING.
-            */
-           if (status <= SERVER_READY) {
-               ++ idle_count;
-               /* always kill the highest numbered child if we have to...
-                * no really well thought out reason ... other than observing
-                * the server behaviour under linux where lower numbered children
-                * tend to service more hits (and hence are more likely to have
-                * their data in cpu caches).
-                */
-               to_kill = i;
-           }
-
-           ++total_non_dead;
-           last_non_dead = i;
-       }
+        int status;
+
+        if (i >= ap_max_daemons_limit && free_length == idle_spawn_rate)
+            break;
+        ws = &ap_scoreboard_image->servers[i][0];
+        status = ws->status;
+        if (status == SERVER_DEAD) {
+            /* try to keep children numbers as low as possible */
+            if (free_length < idle_spawn_rate) {
+                free_slots[free_length] = i;
+                ++free_length;
+            }
+        }
+        else {
+            /* We consider a starting server as idle because we started it
+             * at least a cycle ago, and if it still hasn't finished starting
+             * then we're just going to swamp things worse by forking more.
+             * So we hopefully won't need to fork more if we count it.
+             * This depends on the ordering of SERVER_READY and SERVER_STARTING.
+             */
+            if (status <= SERVER_READY) {
+                ++ idle_count;
+                /* always kill the highest numbered child if we have to...
+                 * no really well thought out reason ... other than observing
+                 * the server behaviour under linux where lower numbered children
+                 * tend to service more hits (and hence are more likely to have
+                 * their data in cpu caches).
+                 */
+                to_kill = i;
+            }
+
+            ++total_non_dead;
+            last_non_dead = i;
+        }
     }
     ap_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
-        * while we were counting
-        */
-       ap_mpm_pod_signal(pod);
-       idle_spawn_rate = 1;
+        /* 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
+         * while we were counting
+         */
+        ap_mpm_pod_signal(pod);
+        idle_spawn_rate = 1;
     }
     else if (idle_count < ap_daemons_min_free) {
-       /* terminate the free list */
-       if (free_length == 0) {
-           /* only report this condition once */
-           static int reported = 0;
-
-           if (!reported) {
-               ap_log_error(APLOG_MARK, APLOG_ERR, 0, ap_server_conf,
-                           "server reached MaxClients setting, consider"
-                           " raising the MaxClients setting");
-               reported = 1;
-           }
-           idle_spawn_rate = 1;
-       }
-       else {
-           if (idle_spawn_rate >= 8) {
-               ap_log_error(APLOG_MARK, APLOG_INFO, 0, ap_server_conf,
-                   "server seems busy, (you may need "
-                   "to increase StartServers, or Min/MaxSpareServers), "
-                   "spawning %d children, there are %d idle, and "
-                   "%d total children", idle_spawn_rate,
-                   idle_count, total_non_dead);
-           }
-           for (i = 0; i < free_length; ++i) {
-#ifdef TPF
-        if (make_child(ap_server_conf, free_slots[i]) == -1) {
-            if(free_length == 1) {
-                shutdown_pending = 1;
-                ap_log_error(APLOG_MARK, APLOG_EMERG, 0, ap_server_conf,
-                "No active child processes: shutting down");
+        /* terminate the free list */
+        if (free_length == 0) {
+            /* only report this condition once */
+            static int reported = 0;
+
+            if (!reported) {
+                ap_log_error(APLOG_MARK, APLOG_ERR, 0, ap_server_conf,
+                            "server reached MaxClients setting, consider"
+                            " raising the MaxClients setting");
+                reported = 1;
             }
+            idle_spawn_rate = 1;
         }
+        else {
+            if (idle_spawn_rate >= 8) {
+                ap_log_error(APLOG_MARK, APLOG_INFO, 0, ap_server_conf,
+                    "server seems busy, (you may need "
+                    "to increase StartServers, or Min/MaxSpareServers), "
+                    "spawning %d children, there are %d idle, and "
+                    "%d total children", idle_spawn_rate,
+                    idle_count, total_non_dead);
+            }
+            for (i = 0; i < free_length; ++i) {
+#ifdef TPF
+                if (make_child(ap_server_conf, free_slots[i]) == -1) {
+                    if(free_length == 1) {
+                        shutdown_pending = 1;
+                        ap_log_error(APLOG_MARK, APLOG_EMERG, 0, ap_server_conf,
+                                    "No active child processes: shutting down");
+                    }
+                }
 #else
-               make_child(ap_server_conf, free_slots[i]);
+                make_child(ap_server_conf, free_slots[i]);
 #endif /* TPF */
-           }
-           /* the next time around we want to spawn twice as many if this
-            * wasn't good enough, but not if we've just done a graceful
-            */
-           if (hold_off_on_exponential_spawning) {
-               --hold_off_on_exponential_spawning;
-           }
-           else if (idle_spawn_rate < MAX_SPAWN_RATE) {
-               idle_spawn_rate *= 2;
-           }
-       }
+            }
+            /* the next time around we want to spawn twice as many if this
+             * wasn't good enough, but not if we've just done a graceful
+             */
+            if (hold_off_on_exponential_spawning) {
+                --hold_off_on_exponential_spawning;
+            }
+            else if (idle_spawn_rate < MAX_SPAWN_RATE) {
+                idle_spawn_rate *= 2;
+            }
+        }
     }
     else {
-       idle_spawn_rate = 1;
+        idle_spawn_rate = 1;
     }
 }
 
@@ -939,70 +941,71 @@ int ap_mpm_run(apr_pool_t *_pconf, apr_pool_t *plog, server_rec *s)
         make_child(ap_server_conf, 0);
     }
     else {
-    if (ap_daemons_max_free < ap_daemons_min_free + 1) /* Don't thrash... */
-       ap_daemons_max_free = ap_daemons_min_free + 1;
+    if (ap_daemons_max_free < ap_daemons_min_free + 1)  /* Don't thrash... */
+        ap_daemons_max_free = ap_daemons_min_free + 1;
 
     /* If we're doing a graceful_restart then we're going to see a lot
-       * of children exiting immediately when we get into the main loop
-       * below (because we just sent them AP_SIG_GRACEFUL).  This happens pretty
-       * rapidly... and for each one that exits we'll start a new one until
-       * we reach at least daemons_min_free.  But we may be permitted to
-       * start more than that, so we'll just keep track of how many we're
-       * supposed to start up without the 1 second penalty between each fork.
-       */
+     * of children exiting immediately when we get into the main loop
+     * below (because we just sent them AP_SIG_GRACEFUL).  This happens pretty
+     * rapidly... and for each one that exits we'll start a new one until
+     * we reach at least daemons_min_free.  But we may be permitted to
+     * start more than that, so we'll just keep track of how many we're
+     * supposed to start up without the 1 second penalty between each fork.
+     */
     remaining_children_to_start = ap_daemons_to_start;
     if (remaining_children_to_start > ap_daemons_limit) {
-       remaining_children_to_start = ap_daemons_limit;
+        remaining_children_to_start = ap_daemons_limit;
     }
     if (!is_graceful) {
-       startup_children(remaining_children_to_start);
-       remaining_children_to_start = 0;
+        startup_children(remaining_children_to_start);
+        remaining_children_to_start = 0;
     }
     else {
-       /* give the system some time to recover before kicking into
-           * exponential mode */
-       hold_off_on_exponential_spawning = 10;
+        /* give the system some time to recover before kicking into
+         * exponential mode
+         */
+        hold_off_on_exponential_spawning = 10;
     }
 
     ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, ap_server_conf,
-               "%s configured -- resuming normal operations",
-               ap_get_server_version());
+                "%s configured -- resuming normal operations",
+                ap_get_server_version());
     ap_log_error(APLOG_MARK, APLOG_INFO, 0, ap_server_conf,
-               "Server built: %s", ap_get_server_built());
+                "Server built: %s", ap_get_server_built());
 #ifdef AP_MPM_WANT_SET_ACCEPT_LOCK_MECH
     ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ap_server_conf,
-               "AcceptMutex: %s (default: %s)",
-               apr_proc_mutex_name(accept_mutex),
-               apr_proc_mutex_defname());
+                "AcceptMutex: %s (default: %s)",
+                apr_proc_mutex_name(accept_mutex),
+                apr_proc_mutex_defname());
 #endif
     restart_pending = shutdown_pending = 0;
 
     mpm_state = AP_MPMQ_RUNNING;
     
     while (!restart_pending && !shutdown_pending) {
-       int child_slot;
+        int child_slot;
         apr_exit_why_e exitwhy;
-       int status, processed_status;
+        int status, processed_status;
         /* this is a memory leak, but I'll fix it later. */
-       apr_proc_t pid;
+        apr_proc_t pid;
 
         ap_wait_or_timeout(&exitwhy, &status, &pid, pconf);
 
-       /* XXX: if it takes longer than 1 second for all our children
-        * to start up and get into IDLE state then we may spawn an
-        * extra child
-        */
-       if (pid.pid != -1) {
+        /* XXX: if it takes longer than 1 second for all our children
+         * to start up and get into IDLE state then we may spawn an
+         * extra child
+         */
+        if (pid.pid != -1) {
             processed_status = ap_process_child_status(&pid, exitwhy, status);
             if (processed_status == APEXIT_CHILDFATAL) {
                 mpm_state = AP_MPMQ_STOPPING;
                 return 1;
             }
 
-           /* non-fatal death... note that it's gone in the scoreboard. */
-           child_slot = find_child_by_pid(&pid);
-           if (child_slot >= 0) {
-               (void) ap_update_child_status_from_indexes(child_slot, 0, SERVER_DEAD,
+            /* non-fatal death... note that it's gone in the scoreboard. */
+            child_slot = find_child_by_pid(&pid);
+            if (child_slot >= 0) {
+                (void) ap_update_child_status_from_indexes(child_slot, 0, SERVER_DEAD,
                                                            (request_rec *) NULL);
                 if (processed_status == APEXIT_CHILDSICK) {
                     /* child detected a resource shortage (E[NM]FILE, ENOBUFS, etc)
@@ -1011,54 +1014,54 @@ int ap_mpm_run(apr_pool_t *_pconf, apr_pool_t *plog, server_rec *s)
                     idle_spawn_rate = 1; 
                 }
                 else if (remaining_children_to_start
-                   && child_slot < ap_daemons_limit) {
-                   /* we're still doing a 1-for-1 replacement of dead
-                       * children with new children
-                       */
-                   make_child(ap_server_conf, child_slot);
-                   --remaining_children_to_start;
-               }
+                    && child_slot < ap_daemons_limit) {
+                    /* we're still doing a 1-for-1 replacement of dead
+                     * children with new children
+                     */
+                    make_child(ap_server_conf, child_slot);
+                    --remaining_children_to_start;
+                }
 #if APR_HAS_OTHER_CHILD
-           }
-           else if (apr_proc_other_child_alert(&pid, APR_OC_REASON_DEATH, status) == APR_SUCCESS) {
-               /* handled */
+            }
+            else if (apr_proc_other_child_alert(&pid, APR_OC_REASON_DEATH, status) == APR_SUCCESS) {
+                /* handled */
 #endif
-           }
-           else if (is_graceful) {
-               /* Great, we've probably just lost a slot in the
-                   * scoreboard.  Somehow we don't know about this
-                   * child.
-                   */
-               ap_log_error(APLOG_MARK, APLOG_WARNING, 
+            }
+            else if (is_graceful) {
+                /* Great, we've probably just lost a slot in the
+                 * scoreboard.  Somehow we don't know about this
+                 * child.
+                 */
+                ap_log_error(APLOG_MARK, APLOG_WARNING, 
                             0, ap_server_conf,
-                           "long lost child came home! (pid %ld)", (long)pid.pid);
-           }
-           /* Don't perform idle maintenance when a child dies,
-               * only do it when there's a timeout.  Remember only a
-               * finite number of children can die, and it's pretty
-               * pathological for a lot to die suddenly.
-               */
-           continue;
-       }
-       else if (remaining_children_to_start) {
-           /* we hit a 1 second timeout in which none of the previous
-               * generation of children needed to be reaped... so assume
-               * they're all done, and pick up the slack if any is left.
-               */
-           startup_children(remaining_children_to_start);
-           remaining_children_to_start = 0;
-           /* In any event we really shouldn't do the code below because
-               * few of the servers we just started are in the IDLE state
-               * yet, so we'd mistakenly create an extra server.
-               */
-           continue;
-       }
-
-       perform_idle_server_maintenance(pconf);
+                            "long lost child came home! (pid %ld)", (long)pid.pid);
+            }
+            /* Don't perform idle maintenance when a child dies,
+             * only do it when there's a timeout.  Remember only a
+             * finite number of children can die, and it's pretty
+             * pathological for a lot to die suddenly.
+             */
+            continue;
+        }
+        else if (remaining_children_to_start) {
+            /* we hit a 1 second timeout in which none of the previous
+             * generation of children needed to be reaped... so assume
+             * they're all done, and pick up the slack if any is left.
+             */
+            startup_children(remaining_children_to_start);
+            remaining_children_to_start = 0;
+            /* In any event we really shouldn't do the code below because
+             * few of the servers we just started are in the IDLE state
+             * yet, so we'd mistakenly create an extra server.
+             */
+            continue;
+        }
+
+        perform_idle_server_maintenance(pconf);
 #ifdef TPF
-    shutdown_pending = os_check_server(tpf_server_name);
-    ap_check_signals();
-    sleep(1);
+        shutdown_pending = os_check_server(tpf_server_name);
+        ap_check_signals();
+        sleep(1);
 #endif /*TPF */
     }
     } /* one_process */
@@ -1066,35 +1069,35 @@ int ap_mpm_run(apr_pool_t *_pconf, apr_pool_t *plog, server_rec *s)
     mpm_state = AP_MPMQ_STOPPING;
 
     if (shutdown_pending) {
-       /* Time to gracefully shut down:
-        * Kill child processes, tell them to call child_exit, etc...
-        */
-       if (unixd_killpg(getpgrp(), SIGTERM) < 0) {
-           ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf, "killpg SIGTERM");
-       }
-       ap_reclaim_child_processes(1);          /* Start with SIGTERM */
-
-       /* cleanup pid file on normal shutdown */
-       {
-           const char *pidfile = NULL;
-           pidfile = ap_server_root_relative (pconf, ap_pid_fname);
-           if ( pidfile != NULL && unlink(pidfile) == 0)
-               ap_log_error(APLOG_MARK, APLOG_INFO,
-                               0, ap_server_conf,
-                               "removed PID file %s (pid=%ld)",
-                               pidfile, (long)getpid());
-       }
-
-       ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, ap_server_conf,
-                   "caught SIGTERM, shutting down");
-       return 1;
+        /* Time to gracefully shut down:
+         * Kill child processes, tell them to call child_exit, etc...
+         */
+        if (unixd_killpg(getpgrp(), SIGTERM) < 0) {
+            ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf, "killpg SIGTERM");
+        }
+        ap_reclaim_child_processes(1);          /* Start with SIGTERM */
+
+        /* cleanup pid file on normal shutdown */
+        {
+            const char *pidfile = NULL;
+            pidfile = ap_server_root_relative (pconf, ap_pid_fname);
+            if ( pidfile != NULL && unlink(pidfile) == 0)
+                ap_log_error(APLOG_MARK, APLOG_INFO,
+                                0, ap_server_conf,
+                                "removed PID file %s (pid=%ld)",
+                                pidfile, (long)getpid());
+        }
+
+        ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, ap_server_conf,
+                    "caught SIGTERM, shutting down");
+        return 1;
     }
 
     /* we've been told to restart */
     apr_signal(SIGHUP, SIG_IGN);
     if (one_process) {
-       /* not worth thinking about */
-       return 1;
+        /* not worth thinking about */
+        return 1;
     }
 
     /* advance to the next generation */
@@ -1105,31 +1108,31 @@ int ap_mpm_run(apr_pool_t *_pconf, apr_pool_t *plog, server_rec *s)
     ap_scoreboard_image->global->running_generation = ap_my_generation;
     
     if (is_graceful) {
-       ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, ap_server_conf,
-                   "Graceful restart requested, doing restart");
+        ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, ap_server_conf,
+                    "Graceful restart requested, doing restart");
 
-       /* kill off the idle ones */
+        /* kill off the idle ones */
         ap_mpm_pod_killpg(pod, ap_max_daemons_limit);
 
-       /* This is mostly for debugging... so that we know what is still
-           * gracefully dealing with existing request.  This will break
-           * in a very nasty way if we ever have the scoreboard totally
-           * file-based (no shared memory)
-           */
-       for (index = 0; index < ap_daemons_limit; ++index) {
-           if (ap_scoreboard_image->servers[index][0].status != SERVER_DEAD) {
-               ap_scoreboard_image->servers[index][0].status = SERVER_GRACEFUL;
-           }
-       }
+        /* This is mostly for debugging... so that we know what is still
+         * gracefully dealing with existing request.  This will break
+         * in a very nasty way if we ever have the scoreboard totally
+         * file-based (no shared memory)
+         */
+        for (index = 0; index < ap_daemons_limit; ++index) {
+            if (ap_scoreboard_image->servers[index][0].status != SERVER_DEAD) {
+                ap_scoreboard_image->servers[index][0].status = SERVER_GRACEFUL;
+            }
+        }
     }
     else {
-       /* Kill 'em off */
-       if (unixd_killpg(getpgrp(), SIGHUP) < 0) {
-           ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf, "killpg SIGHUP");
-       }
-       ap_reclaim_child_processes(0);          /* Not when just starting up */
-       ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, ap_server_conf,
-                   "SIGHUP received.  Attempting to restart");
+        /* Kill 'em off */
+        if (unixd_killpg(getpgrp(), SIGHUP) < 0) {
+            ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf, "killpg SIGHUP");
+        }
+        ap_reclaim_child_processes(0);          /* Not when just starting up */
+        ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, ap_server_conf,
+                    "SIGHUP received.  Attempting to restart");
     }
 
     return 0;
@@ -1148,12 +1151,12 @@ static int prefork_open_logs(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp,
     if ((num_listensocks = ap_setup_listeners(ap_server_conf)) < 1) {
         ap_log_error(APLOG_MARK, APLOG_ALERT|APLOG_STARTUP, 0, 
                      NULL, "no listening sockets available, shutting down");
-       return DONE;
+        return DONE;
     }
 
     if ((rv = ap_mpm_pod_open(pconf, &pod))) {
         ap_log_error(APLOG_MARK, APLOG_CRIT|APLOG_STARTUP, rv, NULL,
-               "Could not open pipe-of-death.");
+                "Could not open pipe-of-death.");
         return DONE;
     }
     return OK;
@@ -1182,7 +1185,7 @@ static int prefork_pre_config(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp
 
     /* sigh, want this only the second time around */
     if (restart_num++ == 1) {
-       is_graceful = 0;
+        is_graceful = 0;
 
         if (!one_process && !foreground) {
             rv = apr_proc_detach(no_detach ? APR_PROC_DETACH_FOREGROUND
@@ -1194,7 +1197,7 @@ static int prefork_pre_config(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp
             }
         }
 
-       parent_pid = ap_my_pid = getpid();
+        parent_pid = ap_my_pid = getpid();
     }
 
     unixd_pre_config(ptemp);
@@ -1208,7 +1211,7 @@ static int prefork_pre_config(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp
     ap_max_requests_per_child = DEFAULT_MAX_REQUESTS_PER_CHILD;
     ap_extended_status = 0;
 #ifdef AP_MPM_WANT_SET_MAX_MEM_FREE
-       ap_max_mem_free = APR_ALLOCATOR_MAX_FREE_UNLIMITED;
+    ap_max_mem_free = APR_ALLOCATOR_MAX_FREE_UNLIMITED;
 #endif
 
     apr_cpystrn(ap_coredump_dir, ap_server_root, sizeof(ap_coredump_dir));
@@ -1298,9 +1301,9 @@ static const char *set_max_clients (cmd_parms *cmd, void *dummy, const char *arg
        ap_daemons_limit = server_limit;
     } 
     else if (ap_daemons_limit < 1) {
-       ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL, 
+        ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL, 
                      "WARNING: Require MaxClients > 0, setting to 1");
-       ap_daemons_limit = 1;
+        ap_daemons_limit = 1;
     }
     return NULL;
 }
@@ -1338,9 +1341,9 @@ static const char *set_server_limit (cmd_parms *cmd, void *dummy, const char *ar
        server_limit = MAX_SERVER_LIMIT;
     } 
     else if (server_limit < 1) {
-       ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL, 
+        ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL, 
                      "WARNING: Require ServerLimit > 0, setting to 1");
-       server_limit = 1;
+        server_limit = 1;
     }
     return NULL;
 }
@@ -1364,10 +1367,10 @@ AP_INIT_TAKE1("ServerLimit", set_server_limit, NULL, RSRC_CONF,
 module AP_MODULE_DECLARE_DATA mpm_prefork_module = {
     MPM20_MODULE_STUFF,
     ap_mpm_rewrite_args,        /* hook to run before apache parses args */
-    NULL,                      /* create per-directory config structure */
-    NULL,                      /* merge per-directory config structures */
-    NULL,                      /* create per-server config structure */
-    NULL,                      /* merge per-server config structures */
-    prefork_cmds,              /* command apr_table_t */
-    prefork_hooks,             /* register hooks */
+    NULL,                       /* create per-directory config structure */
+    NULL,                       /* merge per-directory config structures */
+    NULL,                       /* create per-server config structure */
+    NULL,                       /* merge per-server config structures */
+    prefork_cmds,               /* command apr_table_t */
+    prefork_hooks,              /* register hooks */
 };