]> granicus.if.org Git - apache/blob - server/mpm_unix.c
Add lots of unique tags to error log messages
[apache] / server / mpm_unix.c
1 /* Licensed to the Apache Software Foundation (ASF) under one or more
2  * contributor license agreements.  See the NOTICE file distributed with
3  * this work for additional information regarding copyright ownership.
4  * The ASF licenses this file to You under the Apache License, Version 2.0
5  * (the "License"); you may not use this file except in compliance with
6  * the License.  You may obtain a copy of the License at
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 /* The purpose of this file is to store the code that MOST mpm's will need
18  * this does not mean a function only goes into this file if every MPM needs
19  * it.  It means that if a function is needed by more than one MPM, and
20  * future maintenance would be served by making the code common, then the
21  * function belongs here.
22  *
23  * This is going in src/main because it is not platform specific, it is
24  * specific to multi-process servers, but NOT to Unix.  Which is why it
25  * does not belong in src/os/unix
26  */
27
28 #ifndef WIN32
29
30 #include "apr.h"
31 #include "apr_thread_proc.h"
32 #include "apr_signal.h"
33 #include "apr_strings.h"
34 #define APR_WANT_STRFUNC
35 #include "apr_want.h"
36 #include "apr_getopt.h"
37 #include "apr_optional.h"
38 #include "apr_allocator.h"
39
40 #include "httpd.h"
41 #include "http_config.h"
42 #include "http_core.h"
43 #include "http_log.h"
44 #include "http_main.h"
45 #include "mpm_common.h"
46 #include "ap_mpm.h"
47 #include "ap_listen.h"
48 #include "scoreboard.h"
49 #include "util_mutex.h"
50
51 #ifdef HAVE_PWD_H
52 #include <pwd.h>
53 #endif
54 #ifdef HAVE_GRP_H
55 #include <grp.h>
56 #endif
57 #if APR_HAVE_UNISTD_H
58 #include <unistd.h>
59 #endif
60
61
62 /* we know core's module_index is 0 */
63 #undef APLOG_MODULE_INDEX
64 #define APLOG_MODULE_INDEX AP_CORE_MODULE_INDEX
65
66 typedef enum {DO_NOTHING, SEND_SIGTERM, SEND_SIGKILL, GIVEUP} action_t;
67
68 typedef struct extra_process_t {
69     struct extra_process_t *next;
70     pid_t pid;
71     ap_generation_t gen;
72 } extra_process_t;
73
74 static extra_process_t *extras;
75
76 void ap_register_extra_mpm_process(pid_t pid, ap_generation_t gen)
77 {
78     extra_process_t *p = (extra_process_t *)ap_malloc(sizeof(extra_process_t));
79
80     p->next = extras;
81     p->pid = pid;
82     p->gen = gen;
83     extras = p;
84 }
85
86 int ap_unregister_extra_mpm_process(pid_t pid, ap_generation_t *gen)
87 {
88     extra_process_t *cur = extras;
89     extra_process_t *prev = NULL;
90
91     while (cur && cur->pid != pid) {
92         prev = cur;
93         cur = cur->next;
94     }
95
96     if (cur) {
97         if (prev) {
98             prev->next = cur->next;
99         }
100         else {
101             extras = cur->next;
102         }
103         *gen = cur->gen;
104         free(cur);
105         return 1; /* found */
106     }
107     else {
108         /* we don't know about any such process */
109         return 0;
110     }
111 }
112
113 static int reclaim_one_pid(pid_t pid, action_t action)
114 {
115     apr_proc_t proc;
116     apr_status_t waitret;
117     apr_exit_why_e why;
118     int status;
119
120     /* Ensure pid sanity. */
121     if (pid < 1) {
122         return 1;
123     }
124
125     proc.pid = pid;
126     waitret = apr_proc_wait(&proc, &status, &why, APR_NOWAIT);
127     if (waitret != APR_CHILD_NOTDONE) {
128         if (waitret == APR_CHILD_DONE)
129             ap_process_child_status(&proc, why, status);
130         return 1;
131     }
132
133     switch(action) {
134     case DO_NOTHING:
135         break;
136
137     case SEND_SIGTERM:
138         /* ok, now it's being annoying */
139         ap_log_error(APLOG_MARK, APLOG_WARNING,
140                      0, ap_server_conf, APLOGNO(00045)
141                      "child process %" APR_PID_T_FMT
142                      " still did not exit, "
143                      "sending a SIGTERM",
144                      pid);
145         kill(pid, SIGTERM);
146         break;
147
148     case SEND_SIGKILL:
149         ap_log_error(APLOG_MARK, APLOG_ERR,
150                      0, ap_server_conf, APLOGNO(00046)
151                      "child process %" APR_PID_T_FMT
152                      " still did not exit, "
153                      "sending a SIGKILL",
154                      pid);
155         kill(pid, SIGKILL);
156         break;
157
158     case GIVEUP:
159         /* gave it our best shot, but alas...  If this really
160          * is a child we are trying to kill and it really hasn't
161          * exited, we will likely fail to bind to the port
162          * after the restart.
163          */
164         ap_log_error(APLOG_MARK, APLOG_ERR,
165                      0, ap_server_conf, APLOGNO(00047)
166                      "could not make child process %" APR_PID_T_FMT
167                      " exit, "
168                      "attempting to continue anyway",
169                      pid);
170         break;
171     }
172
173     return 0;
174 }
175
176 void ap_reclaim_child_processes(int terminate,
177                                 ap_reclaim_callback_fn_t *mpm_callback)
178 {
179     apr_time_t waittime = 1024 * 16;
180     int i;
181     extra_process_t *cur_extra;
182     int not_dead_yet;
183     int max_daemons;
184     apr_time_t starttime = apr_time_now();
185     /* this table of actions and elapsed times tells what action is taken
186      * at which elapsed time from starting the reclaim
187      */
188     struct {
189         action_t action;
190         apr_time_t action_time;
191     } action_table[] = {
192         {DO_NOTHING, 0}, /* dummy entry for iterations where we reap
193                           * children but take no action against
194                           * stragglers
195                           */
196         {SEND_SIGTERM, apr_time_from_sec(3)},
197         {SEND_SIGTERM, apr_time_from_sec(5)},
198         {SEND_SIGTERM, apr_time_from_sec(7)},
199         {SEND_SIGKILL, apr_time_from_sec(9)},
200         {GIVEUP,       apr_time_from_sec(10)}
201     };
202     int cur_action;      /* index of action we decided to take this
203                           * iteration
204                           */
205     int next_action = 1; /* index of first real action */
206
207     ap_mpm_query(AP_MPMQ_MAX_DAEMON_USED, &max_daemons);
208
209     do {
210         apr_sleep(waittime);
211         /* don't let waittime get longer than 1 second; otherwise, we don't
212          * react quickly to the last child exiting, and taking action can
213          * be delayed
214          */
215         waittime = waittime * 4;
216         if (waittime > apr_time_from_sec(1)) {
217             waittime = apr_time_from_sec(1);
218         }
219
220         /* see what action to take, if any */
221         if (action_table[next_action].action_time <= apr_time_now() - starttime) {
222             cur_action = next_action;
223             ++next_action;
224         }
225         else {
226             cur_action = 0; /* nothing to do */
227         }
228
229         /* now see who is done */
230         not_dead_yet = 0;
231         for (i = 0; i < max_daemons; ++i) {
232             process_score *ps = ap_get_scoreboard_process(i);
233             pid_t pid = ps->pid;
234
235             if (pid == 0) {
236                 continue; /* not every scoreboard entry is in use */
237             }
238
239             if (reclaim_one_pid(pid, action_table[cur_action].action)) {
240                 mpm_callback(i, 0, 0);
241             }
242             else {
243                 ++not_dead_yet;
244             }
245         }
246
247         cur_extra = extras;
248         while (cur_extra) {
249             ap_generation_t old_gen;
250             extra_process_t *next = cur_extra->next;
251
252             if (reclaim_one_pid(cur_extra->pid, action_table[cur_action].action)) {
253                 if (ap_unregister_extra_mpm_process(cur_extra->pid, &old_gen) == 1) {
254                     mpm_callback(-1, cur_extra->pid, old_gen);
255                 }
256                 else {
257                     AP_DEBUG_ASSERT(1 == 0);
258                 }
259             }
260             else {
261                 ++not_dead_yet;
262             }
263             cur_extra = next;
264         }
265 #if APR_HAS_OTHER_CHILD
266         apr_proc_other_child_refresh_all(APR_OC_REASON_RESTART);
267 #endif
268
269     } while (not_dead_yet > 0 &&
270              action_table[cur_action].action != GIVEUP);
271 }
272
273 void ap_relieve_child_processes(ap_reclaim_callback_fn_t *mpm_callback)
274 {
275     int i;
276     extra_process_t *cur_extra;
277     int max_daemons;
278
279     ap_mpm_query(AP_MPMQ_MAX_DAEMON_USED, &max_daemons);
280
281     /* now see who is done */
282     for (i = 0; i < max_daemons; ++i) {
283         process_score *ps = ap_get_scoreboard_process(i);
284         pid_t pid = ps->pid;
285
286         if (pid == 0) {
287             continue; /* not every scoreboard entry is in use */
288         }
289
290         if (reclaim_one_pid(pid, DO_NOTHING)) {
291             mpm_callback(i, 0, 0);
292         }
293     }
294
295     cur_extra = extras;
296     while (cur_extra) {
297         ap_generation_t old_gen;
298         extra_process_t *next = cur_extra->next;
299
300         if (reclaim_one_pid(cur_extra->pid, DO_NOTHING)) {
301             if (ap_unregister_extra_mpm_process(cur_extra->pid, &old_gen) == 1) {
302                 mpm_callback(-1, cur_extra->pid, old_gen);
303             }
304             else {
305                 AP_DEBUG_ASSERT(1 == 0);
306             }
307         }
308         cur_extra = next;
309     }
310 }
311
312 /* Before sending the signal to the pid this function verifies that
313  * the pid is a member of the current process group; either using
314  * apr_proc_wait(), where waitpid() guarantees to fail for non-child
315  * processes; or by using getpgid() directly, if available. */
316 apr_status_t ap_mpm_safe_kill(pid_t pid, int sig)
317 {
318 #ifndef HAVE_GETPGID
319     apr_proc_t proc;
320     apr_status_t rv;
321     apr_exit_why_e why;
322     int status;
323
324     /* Ensure pid sanity */
325     if (pid < 1) {
326         return APR_EINVAL;
327     }
328
329     proc.pid = pid;
330     rv = apr_proc_wait(&proc, &status, &why, APR_NOWAIT);
331     if (rv == APR_CHILD_DONE) {
332         /* The child already died - log the termination status if
333          * necessary: */
334         ap_process_child_status(&proc, why, status);
335         return APR_EINVAL;
336     }
337     else if (rv != APR_CHILD_NOTDONE) {
338         /* The child is already dead and reaped, or was a bogus pid -
339          * log this either way. */
340         ap_log_error(APLOG_MARK, APLOG_NOTICE, rv, ap_server_conf, APLOGNO(00048)
341                      "cannot send signal %d to pid %ld (non-child or "
342                      "already dead)", sig, (long)pid);
343         return APR_EINVAL;
344     }
345 #else
346     pid_t pg;
347
348     /* Ensure pid sanity. */
349     if (pid < 1) {
350         return APR_EINVAL;
351     }
352
353     pg = getpgid(pid);
354     if (pg == -1) {
355         /* Process already dead... */
356         return errno;
357     }
358
359     if (pg != getpgrp()) {
360         ap_log_error(APLOG_MARK, APLOG_ALERT, 0, ap_server_conf, APLOGNO(00049)
361                      "refusing to send signal %d to pid %ld outside "
362                      "process group", sig, (long)pid);
363         return APR_EINVAL;
364     }
365 #endif
366
367     return kill(pid, sig) ? errno : APR_SUCCESS;
368 }
369
370
371 int ap_process_child_status(apr_proc_t *pid, apr_exit_why_e why, int status)
372 {
373     int signum = status;
374     const char *sigdesc;
375
376     /* Child died... if it died due to a fatal error,
377      * we should simply bail out.  The caller needs to
378      * check for bad rc from us and exit, running any
379      * appropriate cleanups.
380      *
381      * If the child died due to a resource shortage,
382      * the parent should limit the rate of forking
383      */
384     if (APR_PROC_CHECK_EXIT(why)) {
385         if (status == APEXIT_CHILDSICK) {
386             return status;
387         }
388
389         if (status == APEXIT_CHILDFATAL) {
390             ap_log_error(APLOG_MARK, APLOG_ALERT,
391                          0, ap_server_conf, APLOGNO(00050)
392                          "Child %" APR_PID_T_FMT
393                          " returned a Fatal error... Apache is exiting!",
394                          pid->pid);
395             return APEXIT_CHILDFATAL;
396         }
397
398         return 0;
399     }
400
401     if (APR_PROC_CHECK_SIGNALED(why)) {
402         sigdesc = apr_signal_description_get(signum);
403
404         switch (signum) {
405         case SIGTERM:
406         case SIGHUP:
407         case AP_SIG_GRACEFUL:
408         case SIGKILL:
409             break;
410
411         default:
412             if (APR_PROC_CHECK_CORE_DUMP(why)) {
413                 ap_log_error(APLOG_MARK, APLOG_NOTICE,
414                              0, ap_server_conf, APLOGNO(00051)
415                              "child pid %ld exit signal %s (%d), "
416                              "possible coredump in %s",
417                              (long)pid->pid, sigdesc, signum,
418                              ap_coredump_dir);
419             }
420             else {
421                 ap_log_error(APLOG_MARK, APLOG_NOTICE,
422                              0, ap_server_conf, APLOGNO(00052)
423                              "child pid %ld exit signal %s (%d)",
424                              (long)pid->pid, sigdesc, signum);
425             }
426         }
427     }
428     return 0;
429 }
430
431 AP_DECLARE(apr_status_t) ap_mpm_pod_open(apr_pool_t *p, ap_pod_t **pod)
432 {
433     apr_status_t rv;
434
435     *pod = apr_palloc(p, sizeof(**pod));
436     rv = apr_file_pipe_create_ex(&((*pod)->pod_in), &((*pod)->pod_out),
437                                  APR_WRITE_BLOCK, p);
438     if (rv != APR_SUCCESS) {
439         return rv;
440     }
441
442     apr_file_pipe_timeout_set((*pod)->pod_in, 0);
443     (*pod)->p = p;
444
445     /* close these before exec. */
446     apr_file_inherit_unset((*pod)->pod_in);
447     apr_file_inherit_unset((*pod)->pod_out);
448
449     return APR_SUCCESS;
450 }
451
452 AP_DECLARE(apr_status_t) ap_mpm_pod_check(ap_pod_t *pod)
453 {
454     char c;
455     apr_size_t len = 1;
456     apr_status_t rv;
457
458     rv = apr_file_read(pod->pod_in, &c, &len);
459
460     if ((rv == APR_SUCCESS) && (len == 1)) {
461         return APR_SUCCESS;
462     }
463
464     if (rv != APR_SUCCESS) {
465         return rv;
466     }
467
468     return AP_NORESTART;
469 }
470
471 AP_DECLARE(apr_status_t) ap_mpm_pod_close(ap_pod_t *pod)
472 {
473     apr_status_t rv;
474
475     rv = apr_file_close(pod->pod_out);
476     if (rv != APR_SUCCESS) {
477         return rv;
478     }
479
480     rv = apr_file_close(pod->pod_in);
481     if (rv != APR_SUCCESS) {
482         return rv;
483     }
484
485     return APR_SUCCESS;
486 }
487
488 static apr_status_t pod_signal_internal(ap_pod_t *pod)
489 {
490     apr_status_t rv;
491     char char_of_death = '!';
492     apr_size_t one = 1;
493
494     rv = apr_file_write(pod->pod_out, &char_of_death, &one);
495     if (rv != APR_SUCCESS) {
496         ap_log_error(APLOG_MARK, APLOG_WARNING, rv, ap_server_conf, APLOGNO(00053)
497                      "write pipe_of_death");
498     }
499
500     return rv;
501 }
502
503 /* This function connects to the server, then immediately closes the connection.
504  * This permits the MPM to skip the poll when there is only one listening
505  * socket, because it provides a alternate way to unblock an accept() when
506  * the pod is used.
507  */
508 static apr_status_t dummy_connection(ap_pod_t *pod)
509 {
510     char *srequest;
511     apr_status_t rv;
512     apr_socket_t *sock;
513     apr_pool_t *p;
514     apr_size_t len;
515     ap_listen_rec *lp;
516
517     /* create a temporary pool for the socket.  pconf stays around too long */
518     rv = apr_pool_create(&p, pod->p);
519     if (rv != APR_SUCCESS) {
520         return rv;
521     }
522
523     /* If possible, find a listener which is configured for
524      * plain-HTTP, not SSL; using an SSL port would either be
525      * expensive to do correctly (performing a complete SSL handshake)
526      * or cause log spam by doing incorrectly (simply sending EOF). */
527     lp = ap_listeners;
528     while (lp && lp->protocol && strcasecmp(lp->protocol, "http") != 0) {
529         lp = lp->next;
530     }
531     if (!lp) {
532         lp = ap_listeners;
533     }
534
535     rv = apr_socket_create(&sock, lp->bind_addr->family, SOCK_STREAM, 0, p);
536     if (rv != APR_SUCCESS) {
537         ap_log_error(APLOG_MARK, APLOG_WARNING, rv, ap_server_conf, APLOGNO(00054)
538                      "get socket to connect to listener");
539         apr_pool_destroy(p);
540         return rv;
541     }
542
543     /* on some platforms (e.g., FreeBSD), the kernel won't accept many
544      * queued connections before it starts blocking local connects...
545      * we need to keep from blocking too long and instead return an error,
546      * because the MPM won't want to hold up a graceful restart for a
547      * long time
548      */
549     rv = apr_socket_timeout_set(sock, apr_time_from_sec(3));
550     if (rv != APR_SUCCESS) {
551         ap_log_error(APLOG_MARK, APLOG_WARNING, rv, ap_server_conf, APLOGNO(00055)
552                      "set timeout on socket to connect to listener");
553         apr_socket_close(sock);
554         apr_pool_destroy(p);
555         return rv;
556     }
557
558     rv = apr_socket_connect(sock, lp->bind_addr);
559     if (rv != APR_SUCCESS) {
560         int log_level = APLOG_WARNING;
561
562         if (APR_STATUS_IS_TIMEUP(rv)) {
563             /* probably some server processes bailed out already and there
564              * is nobody around to call accept and clear out the kernel
565              * connection queue; usually this is not worth logging
566              */
567             log_level = APLOG_DEBUG;
568         }
569
570         ap_log_error(APLOG_MARK, log_level, rv, ap_server_conf, APLOGNO(00056)
571                      "connect to listener on %pI", lp->bind_addr);
572     }
573
574     /* Create the request string. We include a User-Agent so that
575      * adminstrators can track down the cause of the odd-looking
576      * requests in their logs.
577      */
578     srequest = apr_pstrcat(p, "OPTIONS * HTTP/1.0\r\nUser-Agent: ",
579                            ap_get_server_description(),
580                            " (internal dummy connection)\r\n\r\n", NULL);
581
582     /* Since some operating systems support buffering of data or entire
583      * requests in the kernel, we send a simple request, to make sure
584      * the server pops out of a blocking accept().
585      */
586     /* XXX: This is HTTP specific. We should look at the Protocol for each
587      * listener, and send the correct type of request to trigger any Accept
588      * Filters.
589      */
590     len = strlen(srequest);
591     apr_socket_send(sock, srequest, &len);
592     apr_socket_close(sock);
593     apr_pool_destroy(p);
594
595     return rv;
596 }
597
598 AP_DECLARE(apr_status_t) ap_mpm_pod_signal(ap_pod_t *pod)
599 {
600     apr_status_t rv;
601
602     rv = pod_signal_internal(pod);
603     if (rv != APR_SUCCESS) {
604         return rv;
605     }
606
607     return dummy_connection(pod);
608 }
609
610 void ap_mpm_pod_killpg(ap_pod_t *pod, int num)
611 {
612     int i;
613     apr_status_t rv = APR_SUCCESS;
614
615     /* we don't write anything to the pod here...  we assume
616      * that the would-be reader of the pod has another way to
617      * see that it is time to die once we wake it up
618      *
619      * writing lots of things to the pod at once is very
620      * problematic... we can fill the kernel pipe buffer and
621      * be blocked until somebody consumes some bytes or
622      * we hit a timeout...  if we hit a timeout we can't just
623      * keep trying because maybe we'll never successfully
624      * write again...  but then maybe we'll leave would-be
625      * readers stranded (a number of them could be tied up for
626      * a while serving time-consuming requests)
627      */
628     for (i = 0; i < num && rv == APR_SUCCESS; i++) {
629         rv = dummy_connection(pod);
630     }
631 }
632
633 static const char *dash_k_arg = NULL;
634 static const char *dash_k_arg_noarg = "noarg";
635
636 static int send_signal(pid_t pid, int sig)
637 {
638     if (kill(pid, sig) < 0) {
639         ap_log_error(APLOG_MARK, APLOG_STARTUP, errno, NULL, APLOGNO(00057)
640                      "sending signal to server");
641         return 1;
642     }
643     return 0;
644 }
645
646 int ap_signal_server(int *exit_status, apr_pool_t *pconf)
647 {
648     apr_status_t rv;
649     pid_t otherpid;
650     int running = 0;
651     const char *status;
652
653     *exit_status = 0;
654
655     rv = ap_read_pid(pconf, ap_pid_fname, &otherpid);
656     if (rv != APR_SUCCESS) {
657         if (!APR_STATUS_IS_ENOENT(rv)) {
658             ap_log_error(APLOG_MARK, APLOG_STARTUP, rv, NULL, APLOGNO(00058)
659                          "Error retrieving pid file %s", ap_pid_fname);
660             ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL, APLOGNO(00059)
661                          "Remove it before continuing if it is corrupted.");
662             *exit_status = 1;
663             return 1;
664         }
665         status = "httpd (no pid file) not running";
666     }
667     else {
668         if (kill(otherpid, 0) == 0) {
669             running = 1;
670             status = apr_psprintf(pconf,
671                                   "httpd (pid %" APR_PID_T_FMT ") already "
672                                   "running", otherpid);
673         }
674         else {
675             status = apr_psprintf(pconf,
676                                   "httpd (pid %" APR_PID_T_FMT "?) not running",
677                                   otherpid);
678         }
679     }
680
681     if (!strcmp(dash_k_arg, "start") || dash_k_arg == dash_k_arg_noarg) {
682         if (running) {
683             printf("%s\n", status);
684             return 1;
685         }
686     }
687
688     if (!strcmp(dash_k_arg, "stop")) {
689         if (!running) {
690             printf("%s\n", status);
691         }
692         else {
693             send_signal(otherpid, SIGTERM);
694         }
695         return 1;
696     }
697
698     if (!strcmp(dash_k_arg, "restart")) {
699         if (!running) {
700             printf("httpd not running, trying to start\n");
701         }
702         else {
703             *exit_status = send_signal(otherpid, SIGHUP);
704             return 1;
705         }
706     }
707
708     if (!strcmp(dash_k_arg, "graceful")) {
709         if (!running) {
710             printf("httpd not running, trying to start\n");
711         }
712         else {
713             *exit_status = send_signal(otherpid, AP_SIG_GRACEFUL);
714             return 1;
715         }
716     }
717
718     if (!strcmp(dash_k_arg, "graceful-stop")) {
719         if (!running) {
720             printf("%s\n", status);
721         }
722         else {
723             *exit_status = send_signal(otherpid, AP_SIG_GRACEFUL_STOP);
724         }
725         return 1;
726     }
727
728     return 0;
729 }
730
731 void ap_mpm_rewrite_args(process_rec *process)
732 {
733     apr_array_header_t *mpm_new_argv;
734     apr_status_t rv;
735     apr_getopt_t *opt;
736     char optbuf[3];
737     const char *optarg;
738
739     mpm_new_argv = apr_array_make(process->pool, process->argc,
740                                   sizeof(const char **));
741     *(const char **)apr_array_push(mpm_new_argv) = process->argv[0];
742     apr_getopt_init(&opt, process->pool, process->argc, process->argv);
743     opt->errfn = NULL;
744     optbuf[0] = '-';
745     /* option char returned by apr_getopt() will be stored in optbuf[1] */
746     optbuf[2] = '\0';
747     while ((rv = apr_getopt(opt, "k:" AP_SERVER_BASEARGS,
748                             optbuf + 1, &optarg)) == APR_SUCCESS) {
749         switch(optbuf[1]) {
750         case 'k':
751             if (!dash_k_arg) {
752                 if (!strcmp(optarg, "start") || !strcmp(optarg, "stop") ||
753                     !strcmp(optarg, "restart") || !strcmp(optarg, "graceful") ||
754                     !strcmp(optarg, "graceful-stop")) {
755                     dash_k_arg = optarg;
756                     break;
757                 }
758             }
759         default:
760             *(const char **)apr_array_push(mpm_new_argv) =
761                 apr_pstrdup(process->pool, optbuf);
762             if (optarg) {
763                 *(const char **)apr_array_push(mpm_new_argv) = optarg;
764             }
765         }
766     }
767
768     /* back up to capture the bad argument */
769     if (rv == APR_BADCH || rv == APR_BADARG) {
770         opt->ind--;
771     }
772
773     while (opt->ind < opt->argc) {
774         *(const char **)apr_array_push(mpm_new_argv) =
775             apr_pstrdup(process->pool, opt->argv[opt->ind++]);
776     }
777
778     process->argc = mpm_new_argv->nelts;
779     process->argv = (const char * const *)mpm_new_argv->elts;
780
781     if (NULL == dash_k_arg) {
782         dash_k_arg = dash_k_arg_noarg;
783     }
784
785     APR_REGISTER_OPTIONAL_FN(ap_signal_server);
786 }
787
788 static pid_t parent_pid, my_pid;
789 static apr_pool_t *pconf;
790
791 #if AP_ENABLE_EXCEPTION_HOOK
792
793 static int exception_hook_enabled;
794
795 const char *ap_mpm_set_exception_hook(cmd_parms *cmd, void *dummy,
796                                       const char *arg)
797 {
798     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
799     if (err != NULL) {
800         return err;
801     }
802
803     if (cmd->server->is_virtual) {
804         return "EnableExceptionHook directive not allowed in <VirtualHost>";
805     }
806
807     if (strcasecmp(arg, "on") == 0) {
808         exception_hook_enabled = 1;
809     }
810     else if (strcasecmp(arg, "off") == 0) {
811         exception_hook_enabled = 0;
812     }
813     else {
814         return "parameter must be 'on' or 'off'";
815     }
816
817     return NULL;
818 }
819
820 static void run_fatal_exception_hook(int sig)
821 {
822     ap_exception_info_t ei = {0};
823
824     if (exception_hook_enabled &&
825         geteuid() != 0 &&
826         my_pid != parent_pid) {
827         ei.sig = sig;
828         ei.pid = my_pid;
829         ap_run_fatal_exception(&ei);
830     }
831 }
832 #endif /* AP_ENABLE_EXCEPTION_HOOK */
833
834 /* handle all varieties of core dumping signals */
835 static void sig_coredump(int sig)
836 {
837     apr_filepath_set(ap_coredump_dir, pconf);
838     apr_signal(sig, SIG_DFL);
839 #if AP_ENABLE_EXCEPTION_HOOK
840     run_fatal_exception_hook(sig);
841 #endif
842     /* linuxthreads issue calling getpid() here:
843      *   This comparison won't match if the crashing thread is
844      *   some module's thread that runs in the parent process.
845      *   The fallout, which is limited to linuxthreads:
846      *   The special log message won't be written when such a
847      *   thread in the parent causes the parent to crash.
848      */
849     if (getpid() == parent_pid) {
850         ap_log_error(APLOG_MARK, APLOG_NOTICE,
851                      0, ap_server_conf, APLOGNO(00060)
852                      "seg fault or similar nasty error detected "
853                      "in the parent process");
854         /* XXX we can probably add some rudimentary cleanup code here,
855          * like getting rid of the pid file.  If any additional bad stuff
856          * happens, we are protected from recursive errors taking down the
857          * system since this function is no longer the signal handler   GLA
858          */
859     }
860     kill(getpid(), sig);
861     /* At this point we've got sig blocked, because we're still inside
862      * the signal handler.  When we leave the signal handler it will
863      * be unblocked, and we'll take the signal... and coredump or whatever
864      * is appropriate for this particular Unix.  In addition the parent
865      * will see the real signal we received -- whereas if we called
866      * abort() here, the parent would only see SIGABRT.
867      */
868 }
869
870 apr_status_t ap_fatal_signal_child_setup(server_rec *s)
871 {
872     my_pid = getpid();
873     return APR_SUCCESS;
874 }
875
876 apr_status_t ap_fatal_signal_setup(server_rec *s, apr_pool_t *in_pconf)
877 {
878 #ifndef NO_USE_SIGACTION
879     struct sigaction sa;
880
881     sigemptyset(&sa.sa_mask);
882
883 #if defined(SA_ONESHOT)
884     sa.sa_flags = SA_ONESHOT;
885 #elif defined(SA_RESETHAND)
886     sa.sa_flags = SA_RESETHAND;
887 #else
888     sa.sa_flags = 0;
889 #endif
890
891     sa.sa_handler = sig_coredump;
892     if (sigaction(SIGSEGV, &sa, NULL) < 0)
893         ap_log_error(APLOG_MARK, APLOG_WARNING, errno, s, APLOGNO(00061) "sigaction(SIGSEGV)");
894 #ifdef SIGBUS
895     if (sigaction(SIGBUS, &sa, NULL) < 0)
896         ap_log_error(APLOG_MARK, APLOG_WARNING, errno, s, APLOGNO(00062) "sigaction(SIGBUS)");
897 #endif
898 #ifdef SIGABORT
899     if (sigaction(SIGABORT, &sa, NULL) < 0)
900         ap_log_error(APLOG_MARK, APLOG_WARNING, errno, s, APLOGNO(00063) "sigaction(SIGABORT)");
901 #endif
902 #ifdef SIGABRT
903     if (sigaction(SIGABRT, &sa, NULL) < 0)
904         ap_log_error(APLOG_MARK, APLOG_WARNING, errno, s, APLOGNO(00064) "sigaction(SIGABRT)");
905 #endif
906 #ifdef SIGILL
907     if (sigaction(SIGILL, &sa, NULL) < 0)
908         ap_log_error(APLOG_MARK, APLOG_WARNING, errno, s, APLOGNO(00065) "sigaction(SIGILL)");
909 #endif
910 #ifdef SIGFPE
911     if (sigaction(SIGFPE, &sa, NULL) < 0)
912         ap_log_error(APLOG_MARK, APLOG_WARNING, errno, s, APLOGNO(00066) "sigaction(SIGFPE)");
913 #endif
914
915 #else /* NO_USE_SIGACTION */
916
917     apr_signal(SIGSEGV, sig_coredump);
918 #ifdef SIGBUS
919     apr_signal(SIGBUS, sig_coredump);
920 #endif /* SIGBUS */
921 #ifdef SIGABORT
922     apr_signal(SIGABORT, sig_coredump);
923 #endif /* SIGABORT */
924 #ifdef SIGABRT
925     apr_signal(SIGABRT, sig_coredump);
926 #endif /* SIGABRT */
927 #ifdef SIGILL
928     apr_signal(SIGILL, sig_coredump);
929 #endif /* SIGILL */
930 #ifdef SIGFPE
931     apr_signal(SIGFPE, sig_coredump);
932 #endif /* SIGFPE */
933
934 #endif /* NO_USE_SIGACTION */
935
936     pconf = in_pconf;
937     parent_pid = my_pid = getpid();
938
939     return APR_SUCCESS;
940 }
941
942 #endif /* WIN32 */