int test(){
#ifdef _OSD_POSIX
if ((pid = os_fork(ap_unixd_config.user_name)) == -1) {
#else
if ((pid = fork()) == -1) {
#endif
// code
}
}
static int make_child(server_rec *s, int slot)
{
int pid;
if (slot + 1 > ap_max_daemons_limit) {
ap_max_daemons_limit = slot + 1;
}
if (one_process) {
apr_signal(SIGHUP, just_die);
/* Don't catch AP_SIG_GRACEFUL in ONE_PROCESS mode :) */
apr_signal(SIGINT, just_die);
#ifdef SIGQUIT
apr_signal(SIGQUIT, SIG_DFL);
#endif
apr_signal(SIGTERM, just_die);
child_main(slot);
}
(void) ap_update_child_status_from_indexes(slot, 0, SERVER_STARTING,
(request_rec *) NULL);
#ifdef _OSD_POSIX
/* BS2000 requires a "special" version of fork() before a setuid() call */
if ((pid = os_fork(unixd_config.user_name)) == -1) {
#elif defined(TPF)
if ((pid = os_fork(s, slot)) == -1) {
#else
if ((pid = fork()) == -1) {
#endif
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,
(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);
return -1;
}
if (!pid) {
#ifdef HAVE_BINDPROCESSOR
/* 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,
ap_server_conf, "processor unbind failed %d", status);
}
#endif
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);
/* 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);
}
ap_scoreboard_image->parent[slot].pid = pid;
return 0;
}
/* start up a bunch of children */
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;
}
}
/*
* idle_spawn_rate is the number of children that will be spawned on the
* next maintenance cycle if there aren't enough idle servers. It is
* doubled up to MAX_SPAWN_RATE, and reset only when a cycle goes by
* without the need to spawn.
*/
static int idle_spawn_rate = 1;
#ifndef MAX_SPAWN_RATE
#define MAX_SPAWN_RATE (32)
#endif
static int hold_off_on_exponential_spawning;
static void perform_idle_server_maintenance(apr_pool_t *p)
{
int i;
int to_kill;
int idle_count;
worker_score *ws;
int free_length;
int free_slots[MAX_SPAWN_RATE];
int last_non_dead;
int total_non_dead;
/* initialize the free_list */
free_length = 0;
to_kill = -1;
idle_count = 0;
last_non_dead = -1;
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;
}
}
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;
}
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");
}
}
#else
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;
}
}
}
else {
idle_spawn_rate = 1;
}
}
