+ switch (signum) {
+ case 0:
+ return;
+ case SIGHUP:
+ handle_sighup();
+ break;
+ case SIGCHLD:
+ for (;;) {
+ pid_t pid;
+ int ret = para_reap_child(&pid);
+ if (ret <= 0)
+ break;
+ if (pid != mmd->afs_pid)
+ continue;
+ PARA_EMERG_LOG("fatal: afs died\n");
+ kill(0, SIGTERM);
+ goto cleanup;
+ }
+ break;
+ /* die on sigint/sigterm. Kill all children too. */
+ case SIGINT:
+ case SIGTERM:
+ PARA_EMERG_LOG("terminating on signal %d\n", signum);
+ kill(0, SIGTERM);
+ /*
+ * We must wait for afs because afs catches SIGINT/SIGTERM.
+ * Before reacting to the signal, afs might want to use the
+ * shared memory area and the mmd mutex. If we destroy this
+ * mutex too early and afs tries to lock the shared memory
+ * area, the call to mutex_lock() will fail and terminate the
+ * afs process. This leads to dirty osl tables.
+ *
+ * There's no such problem with the other children of the
+ * server process (the command handlers) as these reset their
+ * SIGINT/SIGTERM handlers to the default action, i.e. these
+ * processes get killed immediately by the above kill().
+ */
+ PARA_INFO_LOG("waiting for afs (pid %d) to die\n",
+ (int)mmd->afs_pid);
+ waitpid(mmd->afs_pid, NULL, 0);
+cleanup:
+ free(mmd->afd.afhi.chunk_table);
+ close_listed_fds();
+ mutex_destroy(mmd_mutex);
+ shm_detach(mmd);
+ exit(EXIT_FAILURE);
+ }
+}
+
+static void init_signal_task(void)
+{
+ static struct signal_task signal_task_struct,
+ *st = &signal_task_struct;
+
+ st->task.pre_select = signal_pre_select;
+ st->task.post_select = signal_post_select;
+ sprintf(st->task.status, "signal task");
+
+ PARA_NOTICE_LOG("setting up signal handling\n");
+ st->fd = para_signal_init(); /* always successful */
+ para_install_sighandler(SIGINT);
+ para_install_sighandler(SIGTERM);
+ para_install_sighandler(SIGHUP);
+ para_install_sighandler(SIGCHLD);
+ para_sigaction(SIGPIPE, SIG_IGN);
+ add_close_on_fork_list(st->fd);
+ register_task(&sched, &st->task);