* Actual definitions of config globals
*/
-int ap_threads_per_child=0; /* Worker threads per child */
+int ap_threads_per_child=HARD_THREAD_LIMIT; /* Worker threads per child */
int ap_max_requests_per_child=0;
static const char *ap_pid_fname=NULL;
-static const char *ap_scoreboard_fname=NULL;
static int ap_threads_to_start=0;
static int min_spare_threads=0;
static int max_spare_threads=0;
static int ap_thread_limit=0;
-AP_DECLARE_DATA int ap_extended_status = 0;
static int num_listening_sockets = 0; /* set by open_listeners in ap_mpm_run */
static apr_socket_t ** listening_sockets;
apr_lock_t *accept_mutex = NULL;
apr_pool_t *tpool;
} proc_info;
-struct ap_ctable ap_child_table[HARD_SERVER_LIMIT];
-
/*
* The max child slot ever assigned, preserved across restarts. Necessary
* to deal with MaxClients changes across SIGWINCH restarts. We use this
int ap_max_child_assigned = -1;
int ap_max_threads_limit = -1;
char ap_coredump_dir[MAX_STRING_LEN];
+
+
static volatile bool flag_of_death;
+static int udp_sock;
+static struct sockaddr_in udpsi;
/* shared http_main globals... */
static int volatile shutdown_pending;
static int volatile restart_pending;
static int volatile is_graceful;
+ap_generation_t volatile ap_my_generation = 0;
/*
* ap_start_shutdown() and ap_start_restart(), below, are a first stab at
}
restart_pending = 1;
is_graceful = graceful;
+ if (is_graceful){
+ apr_pool_cleanup_kill(pconf, NULL, ap_cleanup_scoreboard);
+ }
}
static void sig_term(int sig)
static void tell_workers_to_exit(void)
{
flag_of_death = true;
-}
-
-static void push_workers_off_cliff(int sig)
-{
- int i;
-
- for (i=0;i<ap_max_child_assigned;i++)
- kill(ap_child_table[i].pid, sig);
+ sendto(udp_sock, "die!", 4, 0, (struct sockaddr*)&udpsi, sizeof(udpsi));
}
static void set_signals(void)
apr_socket_close(sock);
return;
}
-
+
current_conn = ap_new_connection(p, ap_server_conf, sock, conn_id);
+
if (current_conn) {
ap_process_connection(current_conn);
ap_lingering_close(current_conn);
worker_thread_count++;
apr_lock_release(worker_thread_count_mutex);
+ (void) ap_update_child_status(0, child_slot, SERVER_STARTING,
+ (request_rec*)NULL);
+
apr_poll_setup(&pollset, num_listening_sockets, tpool);
- for(n=0 ; n < num_listening_sockets ; ++n)
+ for(n=0 ; n <= num_listening_sockets ; ++n)
apr_poll_socket_add(pollset, listening_sockets[n], APR_POLLIN);
while (!this_worker_should_exit) {
if (this_worker_should_exit) break;
+ (void) ap_update_child_status(0, child_slot, SERVER_READY,
+ (request_rec*)NULL);
+
apr_lock_aquire(accept_mutex);
while (!this_worker_should_exit) {
apr_int16_t event;
if (flag_of_death)
this_worker_should_exit = 1;
+ apr_poll_revents_get(&event, listening_sockets[0], pollset);
+ if (event & APR_POLLIN)
+ this_worker_should_exit = 1;
+
if (ret != APR_SUCCESS) {
if (errno == EINTR) {
continue;
apr_clear_pool(ptrans);
}
- apr_pool_destroy(tpool);
+ ap_update_child_status(0, child_slot, SERVER_DEAD, (request_rec*)NULL);
+
apr_lock_aquire(worker_thread_count_mutex);
worker_thread_count--;
- if (worker_thread_count == 0) {
- /* All the threads have exited, now finish the shutdown process
- * by signalling the sigwait thread */
- kill(server_pid, SIGTERM);
- }
apr_lock_release(worker_thread_count_mutex);
return (0);
static int make_worker(server_rec *s, int slot)
{
thread_id tid;
- proc_info *my_info = (proc_info *)malloc(sizeof(proc_info));
+ proc_info *my_info = (proc_info *)malloc(sizeof(proc_info)); /* freed by thread... */
if (my_info == NULL) {
ap_log_error(APLOG_MARK, APLOG_ALERT, errno, ap_server_conf,
if (one_process) {
set_signals();
- ap_child_table[slot].pid = getpid();
- ap_child_table[slot].status = SERVER_ALIVE;
+ ap_scoreboard_image->parent[0].pid = getpid();
return 0;
}
+ (void) ap_update_child_status(0, slot, SERVER_STARTING, (request_rec*)NULL);
tid = spawn_thread(worker_thread, "apache_worker", B_NORMAL_PRIORITY,
my_info);
if (tid < B_NO_ERROR) {
/* 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. */
+ (void) ap_update_child_status(0, slot, SERVER_DEAD,
+ (request_rec*)NULL);
+
sleep(10);
-
+ free(my_info);
+
return -1;
}
resume_thread(tid);
-
- ap_child_table[slot].pid = tid;
- ap_child_table[slot].status = SERVER_ALIVE;
+
+ ap_scoreboard_image->servers[0][slot].tid = tid;
return 0;
}
{
int i;
+ ap_log_error(APLOG_MARK, APLOG_ERR, 0, NULL,
+ "starting %d threads", number_to_start);
+
for (i = 0; number_to_start && i < ap_thread_limit; ++i) {
- if (ap_child_table[i].pid) {
+ if (ap_scoreboard_image->servers[0][i].tid) {
continue;
}
if (make_worker(ap_server_conf, i) < 0) {
free_length = 0;
for (i = 0; i < ap_thread_limit; ++i) {
- if (ap_child_table[i].pid == 0) {
+ if (ap_scoreboard_image->servers[0][i].tid == 0) {
if (free_length < spawn_rate) {
free_slots[free_length] = i;
++free_length;
/* non-fatal death... note that it's gone in the scoreboard. */
child_slot = -1;
for (i = 0; i < ap_max_child_assigned; ++i) {
- if (ap_child_table[i].pid == pid.pid) {
- int j;
-
+ if (ap_scoreboard_image->servers[0][i].tid == pid.pid) {
child_slot = i;
- for (j = 0; j < HARD_THREAD_LIMIT; j++) {
- ap_beos_force_reset_connection_status(i * HARD_THREAD_LIMIT + j);
- }
break;
}
}
if (child_slot >= 0) {
- ap_child_table[child_slot].pid = 0;
+ ap_scoreboard_image->servers[0][child_slot].tid = 0;
+ (void) ap_update_child_status(0, child_slot, SERVER_DEAD, (request_rec*)NULL);
- if (remaining_threads_to_start
- && child_slot < ap_thread_limit) {
- /* we're still doing a 1-for-1 replacement of dead
+ if (remaining_threads_to_start
+ && child_slot < ap_thread_limit) {
+ /* we're still doing a 1-for-1 replacement of dead
* children with new children
*/
- make_worker(ap_server_conf, child_slot);
- --remaining_threads_to_start;
- }
+ make_worker(ap_server_conf, child_slot);
+ --remaining_threads_to_start;
+ }
#if APR_HAS_OTHER_CHILD
- }
- else if (apr_proc_other_child_read(&pid, status) == 0) {
- /* handled */
+ }
+ else if (apr_proc_other_child_read(&pid, status) == 0) {
+ /* 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_NOERRNO|APLOG_WARNING, 0, ap_server_conf,
- "long lost child came home! (pid %ld)", pid.pid);
- }
+ }
+ 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_NOERRNO|APLOG_WARNING, 0, ap_server_conf,
+ "long lost child came home! (pid %ld)", 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_threads_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_threads(remaining_threads_to_start);
- remaining_threads_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();
+ /* 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_threads_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_threads(remaining_threads_to_start);
+ remaining_threads_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();
}
}
int ap_mpm_run(apr_pool_t *_pconf, apr_pool_t *plog, server_rec *s)
{
- int remaining_threads_to_start, i;
+ int remaining_threads_to_start, i,j;
apr_status_t rv;
ap_listen_rec *lr;
pconf = _pconf;
ap_server_conf = s;
-
+
+ ap_scoreboard_fname = DEFAULT_SCOREBOARD;
+
+ if ((udp_sock = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP)) < 0){
+ ap_log_error(APLOG_MARK, APLOG_ALERT, errno, s,
+ "couldn't create control socket, shutting down");
+ return 1;
+ }
+
+ /* now build the udp sockaddr_in structure... */
+ udpsi.sin_len = sizeof(struct sockaddr_in);
+ udpsi.sin_family = AF_INET;
+ udpsi.sin_port = htons(7777);
+ udpsi.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+ if (bind(udp_sock, (struct sockaddr*)&udpsi, sizeof(udpsi)) < 0){
+ ap_log_error(APLOG_MARK, APLOG_ALERT, errno, s,
+ "couldn't bind the control socket, shutting down");
+ return 1;
+ }
+
if ((num_listening_sockets = ap_setup_listeners(ap_server_conf)) < 1) {
ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_ALERT, 0, s,
"no listening sockets available, shutting down");
}
ap_log_pid(pconf, ap_pid_fname);
-
flag_of_death = false;
/*
"Couldn't create accept lock");
return 1;
}
+
/* worker_thread_count_mutex
* locks the worker_thread_count so we have ana ccurate count...
*/
if (!is_graceful)
ap_create_scoreboard(pconf, SB_SHARED);
+ if (!is_graceful) {
+ for (i = 0; i < HARD_SERVER_LIMIT; i++) {
+ ap_scoreboard_image->parent[i].pid = 0;
+ for (j = 0;j < HARD_THREAD_LIMIT; j++)
+ ap_scoreboard_image->servers[i][j].tid = 0;
+ }
+ }
+ if (HARD_SERVER_LIMIT == 1)
+ ap_scoreboard_image->parent[0].pid = getpid();
+
set_signals();
- /* Sanity cehcks to avoid thrashing... */
+
+ /* Sanity checks to avoid thrashing... */
if (max_spare_threads < min_spare_threads )
max_spare_threads = min_spare_threads;
* the listenfds and creat the pollset...
*/
listening_sockets = apr_palloc(pchild,
- sizeof(*listening_sockets) * (num_listening_sockets));
- for (lr = ap_listeners, i = 0; i < num_listening_sockets; lr = lr->next, ++i)
+ sizeof(*listening_sockets) * (num_listening_sockets + 1));
+
+ apr_os_sock_put(&listening_sockets[0], &udp_sock, pchild);
+
+ for (lr = ap_listeners, i = 1; i <= num_listening_sockets; lr = lr->next, ++i)
listening_sockets[i]=lr->sd;
/* we assume all goes OK...hmm might want to check that! */
ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_NOTICE, 0, ap_server_conf,
"%s configured -- resuming normal operations",
ap_get_server_version());
+
ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_INFO, 0, ap_server_conf,
"Server built: %s", ap_get_server_built());
+
restart_pending = shutdown_pending = 0;
/*
* main_loop until it's all over
*/
server_main_loop(remaining_threads_to_start);
+
+ tell_workers_to_exit(); /* if we get here we're exiting... */
+ sleep(1); /* give them a brief chance to exit */
+ /* close the UDP socket we've been using... */
+ apr_socket_close(listening_sockets[0]);
+
/*
* If we get here we're shutting down...
*/
ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_NOTICE, 0, ap_server_conf,
"caught SIGTERM, shutting down");
- return 1;
+ return 1;
}
/* we've been told to restart */
if (is_graceful) {
ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_NOTICE, 0, ap_server_conf,
"SIGWINCH received. Doing graceful restart");
- tell_workers_to_exit();
- /* TODO - need to test some ideas here... */
}
else {
/* Kill 'em all. Since the child acts the same on the parents SIGTERM
* and a SIGHUP, we may as well use the same signal, because some user
* pthreads are stealing signals from us left and right.
*/
- push_workers_off_cliff(SIGTERM);
ap_reclaim_child_processes(1); /* Start with SIGTERM */
ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_NOTICE, 0, ap_server_conf,
/* sigh, want this only the second time around */
if (restart_num++ == 1) {
is_graceful = 0;
+
if (!one_process && !no_detach)
apr_proc_detach();
+
server_pid = getpid();
}
beosd_pre_config();
ap_listen_pre_config();
ap_threads_to_start = DEFAULT_START_THREADS;
- min_spare_threads = DEFAULT_MIN_FREE_DAEMON * DEFAULT_THREADS_PER_CHILD;
- max_spare_threads = DEFAULT_MAX_FREE_DAEMON * DEFAULT_THREADS_PER_CHILD;
- ap_thread_limit = HARD_SERVER_LIMIT;
+ min_spare_threads = DEFAULT_MIN_FREE_THREADS;
+ max_spare_threads = DEFAULT_MAX_FREE_THREADS;
+ ap_thread_limit = HARD_THREAD_LIMIT;
ap_threads_per_child = DEFAULT_THREADS_PER_CHILD;
ap_pid_fname = DEFAULT_PIDLOG;
+ ap_scoreboard_fname = DEFAULT_SCOREBOARD;
ap_max_requests_per_child = DEFAULT_MAX_REQUESTS_PER_CHILD;
- ap_beos_set_maintain_connection_status(1);
apr_cpystrn(ap_coredump_dir, ap_server_root, sizeof(ap_coredump_dir));
}
return NULL;
}
-static const char *set_maintain_connection_status(cmd_parms *cmd,
- void *dummy, int arg)
-{
- const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
- if (err != NULL) {
- return err;
- }
-
- ap_beos_set_maintain_connection_status(arg != 0);
- return NULL;
-}
-
static const char *set_coredumpdir (cmd_parms *cmd, void *dummy, const char *arg)
{
apr_finfo_t finfo;
"Number of threads each child creates" ),
AP_INIT_TAKE1( "MaxRequestsPerChild", set_max_requests, NULL, RSRC_CONF,
"Maximum number of requests a particular child serves before dying." ),
-AP_INIT_FLAG( "ConnectionStatus", set_maintain_connection_status, NULL, RSRC_CONF,
- "Whether or not to maintain status information on current connections." ),
AP_INIT_TAKE1( "CoreDumpDirectory", set_coredumpdir, NULL, RSRC_CONF,
"The location of the directory Apache changes to before dumping core" ),
{ NULL }
projects / apache / commitdiff