Manjusaka

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main() {
  int pid;
  if ((pid = fork()) == 0) {
    printf("子プロセスです\n");
  } else {
    printf("子プロセスの PID は %d です\n", pid);
    sleep(20);
  }
  return 0;
}

#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <sys/epoll.h>
#include <sys/signalfd.h>
#include <sys/wait.h>

#define MAXEVENTS 64
void deletejob(pid_t pid) { printf("タスク %d を削除します\n", pid); }

void addjob(pid_t pid) { printf("タスク %d を追加します\n", pid); }

int main(int argc, char **argv) {
  int pid;
  struct epoll_event event;
  struct epoll_event *events;
  sigset_t mask;
  sigemptyset(&mask);
  sigaddset(&mask, SIGCHLD);
  if (sigprocmask(SIG_SETMASK, &mask, NULL) < 0) {
    perror("sigprocmask");
    return 1;
  }
  int sfd = signalfd(-1, &mask, 0);
  int epoll_fd = epoll_create(MAXEVENTS);
  event.events = EPOLLIN | EPOLLEXCLUSIVE | EPOLLET;
  event.data.fd = sfd;
  int s = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sfd, &event);
  if (s == -1) {
    abort();
  }
  events = calloc(MAXEVENTS, sizeof(event));
  while (1) {
    int n = epoll_wait(epoll_fd, events, MAXEVENTS, 1);
    if (n == -1) {
      if (errno == EINTR) {
        fprintf(stderr, "epoll EINTR エラー\n");
      } else if (errno == EINVAL) {
        fprintf(stderr, "epoll EINVAL エラー\n");
      } else if (errno == EFAULT) {
        fprintf(stderr, "epoll EFAULT エラー\n");
        exit(-1);
      } else if (errno == EBADF) {
        fprintf(stderr, "epoll EBADF エラー\n");
        exit(-1);
      }
    }
    printf("%d\n", n);
    for (int i = 0; i < n; i++) {
      if ((events[i].events & EPOLLERR) || (events[i].events & EPOLLHUP) ||
          (!(events[i].events & EPOLLIN))) {
        printf("%d\n", i);
        fprintf(stderr, "epoll エラー\n");
        close(events[i].data.fd);
        continue;
      } else if (sfd == events[i].data.fd) {
        struct signalfd_siginfo si;
        ssize_t res = read(sfd, &si, sizeof(si));
        if (res < 0) {
          fprintf(stderr, "読み取りエラー\n");
          continue;
        }
        if (res != sizeof(si)) {
          fprintf(stderr, "何かが間違っています\n");
          continue;
        }
        if (si.ssi_signo == SIGCHLD) {
          printf("SIGCHLD を受信しました\n");
          int child_pid = waitpid(-1, NULL, 0);
          deletejob(child_pid);
        }
      }
    }
    if ((pid = fork()) == 0) {
      execve("/bin/date", argv, NULL);
    }
    addjob(pid);
  }
}

#include <stdio.h>
#include <sys/prctl.h>
#include <sys/types.h>
#include <unistd.h>

int main() {
  int pid;
  int err = prctl(PR_SET_CHILD_SUBREAPER, 1);
  if (err != 0) {
    return 0;
  }
  if ((pid = fork()) == 0) {
    if ((pid = fork()) == 0) {
      printf("子プロセス1です\n");
      sleep(20);
    } else {
      printf("子プロセスの PID は %d です\n", pid);
    }
  } else {
    sleep(40);
  }
  return 0;
}

/*
 * 私たちが死ぬとき、すべての子プロセスを re-parent しようとします。
 * 1. もしスレッドグループ内に他のスレッドが存在すれば、それに渡します。
 * 2. 子プロセスのために自分自身を子サブリーパーとして設定した最初の祖先プロセスに渡します（サービスマネージャーのように）。
 * 3. 前述の2つが無効な場合、現在の PID 名前空間の init プロセス（PID 1）に渡します。
 */
static struct task_struct *find_new_reaper(struct task_struct *father,
					   struct task_struct *child_reaper)
{
	struct task_struct *thread, *reaper;

	thread = find_alive_thread(father);
	if (thread)
		return thread;

	if (father->signal->has_child_subreaper) {
		unsigned int ns_level = task_pid(father)->level;
		/*
		 * 現在の PID 名前空間内で最初の ->is_child_subreaper 祖先を見つけます。
		 * reaper != child_reaper をチェックできないのは、名前空間を越えないようにするためです。
		 * exiting parent は setns() + fork() によって注入される可能性があります。
		 * pid->level をチェックします。これは、task_active_pid_ns(reaper) != task_active_pid_ns(father) よりもわずかに効率的です。
		 */
		for (reaper = father->real_parent;
		     task_pid(reaper)->level == ns_level;
		     reaper = reaper->real_parent) {
			if (reaper == &init_task)
				break;
			if (!reaper->signal->is_child_subreaper)
				continue;
			thread = find_alive_thread(reaper);
			if (thread)
				return thread;
		}
	}

	return child_reaper;
}

int register_subreaper () {
	if (subreaper > 0) {
		if (prctl(PR_SET_CHILD_SUBREAPER, 1)) {
			if (errno == EINVAL) {
				PRINT_FATAL("PR_SET_CHILD_SUBREAPER はこのプラットフォームでは利用できません。Linux >= 3.4 を使用していますか？")
			} else {
				PRINT_FATAL("子サブリーパーとして登録に失敗しました: %s", strerror(errno))
			}
			return 1;
		} else {
			PRINT_TRACE("子サブリーパーとして登録されました");
		}
	}
	return 0;
}

int wait_and_forward_signal(sigset_t const* const parent_sigset_ptr, pid_t const child_pid) {
	siginfo_t sig;

	if (sigtimedwait(parent_sigset_ptr, &sig, &ts) == -1) {
		switch (errno) {
			case EAGAIN:
				break;
			case EINTR:
				break;
			default:
				PRINT_FATAL("sigtimedwait で予期しないエラーが発生しました: '%s'", strerror(errno));
				return 1;
		}
	} else {
		/* ここで処理すべき信号があります */
		switch (sig.si_signo) {
			case SIGCHLD:
				/* 特別に処理されます。SIGCHLD は転送しません。代わりに、プロセスを回収します。 */
				PRINT_DEBUG("SIGCHLD を受信しました");
				break;
			default:
				PRINT_DEBUG("信号を転送します: '%s'", strsignal(sig.si_signo));
				/* 他の信号を転送します */
				if (kill(kill_process_group ? -child_pid : child_pid, sig.si_signo)) {
					if (errno == ESRCH) {
						PRINT_WARNING("子プロセスは信号転送時に死亡していました");
					} else {
						PRINT_FATAL("信号転送時に予期しないエラーが発生しました: '%s'", strerror(errno));
						return 1;
					}
				}
				break;
		}
	}

	return 0;
}