#include <sys/atomic.h>
#include <sys/wait.h>

#include <assert.h>
#include <err.h>
#include <errno.h>
#include <pthread.h>
#include <sched.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#define	_SigNotify	0x01
#define	_SigDefault	0x02
#define	_SigThrow	0x04
#define	_SigUnblock	0x08
#define	_SigPanic	0x10
#define	_SigKill	0x20
#define	_SigIgn		0x40

static struct {
	int flags;
	const char *name;
} sigtable[_NSIG] = {
        /*  0 */ {0, "SIGNONE: no trap"},
        /*  1 */ {_SigNotify + _SigKill, "SIGHUP: terminal line hangup"},
        /*  2 */ {_SigNotify + _SigKill, "SIGINT: interrupt"},
        /*  3 */ {_SigNotify + _SigThrow, "SIGQUIT: quit"},
        /*  4 */ {_SigThrow + _SigUnblock, "SIGILL: illegal instruction"},
        /*  5 */ {_SigThrow + _SigUnblock, "SIGTRAP: trace trap"},
        /*  6 */ {_SigNotify + _SigThrow, "SIGABRT: abort"},
        /*  7 */ {_SigThrow, "SIGEMT: emulate instruction executed"},
        /*  8 */ {_SigPanic + _SigUnblock, "SIGFPE: floating-point exception"},
        /*  9 */ {0, "SIGKILL: kill"},
        /* 10 */ {_SigPanic + _SigUnblock, "SIGBUS: bus error"},
        /* 11 */ {_SigPanic + _SigUnblock, "SIGSEGV: segmentation violation"},
        /* 12 */ {_SigThrow, "SIGSYS: bad system call"},
        /* 13 */ {_SigNotify, "SIGPIPE: write to broken pipe"},
        /* 14 */ {_SigNotify, "SIGALRM: alarm clock"},
        /* 15 */ {_SigNotify + _SigKill, "SIGTERM: termination"},
        /* 16 */ {_SigNotify + _SigIgn, "SIGURG: urgent condition on socket"},
        /* 17 */ {0, "SIGSTOP: stop"},
        /* 18 */ {_SigNotify + _SigDefault + _SigIgn, "SIGTSTP: keyboard stop"},
        /* 19 */ {_SigNotify + _SigDefault + _SigIgn, "SIGCONT: continue after stop"},
        /* 20 */ {_SigNotify + _SigUnblock + _SigIgn, "SIGCHLD: child status has changed"},
        /* 21 */ {_SigNotify + _SigDefault + _SigIgn, "SIGTTIN: background read from tty"},
        /* 22 */ {_SigNotify + _SigDefault + _SigIgn, "SIGTTOU: background write to tty"},
        /* 23 */ {_SigNotify + _SigIgn, "SIGIO: i/o now possible"},
        /* 24 */ {_SigNotify, "SIGXCPU: cpu limit exceeded"},
        /* 25 */ {_SigNotify, "SIGXFSZ: file size limit exceeded"},
        /* 26 */ {_SigNotify, "SIGVTALRM: virtual alarm clock"},
        /* 27 */ {_SigNotify + _SigUnblock, "SIGPROF: profiling alarm clock"},
        /* 28 */ {_SigNotify + _SigIgn, "SIGWINCH: window size change"},
        /* 29 */ {_SigNotify + _SigIgn, "SIGINFO: status request from keyboard"},
        /* 30 */ {_SigNotify, "SIGUSR1: user-defined signal 1"},
        /* 31 */ {_SigNotify, "SIGUSR2: user-defined signal 2"},
        /* 32 */ {_SigNotify, "SIGTHR: reserved"},
};

sigset_t sigset_all;

volatile unsigned forked = 0;
volatile unsigned ready = 0;

static void
handler(int signo, siginfo_t *si, void *ctx)
{

	if (sigtable[signo].flags & _SigIgn)
		return;
	_exit(128 + signo);
}

pid_t __fork(void);

static void *
start(void *cookie)
{
	stack_t st;
	struct sigaction sa;
	unsigned i;
	pid_t pid;

	/* mstart0 */
	memset(&st, 0, sizeof(st));
	st.ss_size = 0;
	st.ss_sp = NULL;
	st.ss_flags = SS_DISABLE;
	if (sigaltstack(&st, NULL) == -1)
		err(1, "disable sigaltstack");

	/* minit */
	memset(&st, 0, sizeof(st));
	st.ss_size = 32 * 1024;
	st.ss_sp = malloc(st.ss_size);
	if (st.ss_sp == NULL)
		err(1, "malloc");
	st.ss_flags = 0;
	if (sigaltstack(&st, NULL) == -1)
		err(1, "sigaltstack");

	/* initsig */
	for (i = 0; i < _NSIG; i++) {
		if (sigtable[i].flags == 0 || sigtable[i].flags & _SigDefault)
			continue;
		/* setsig */
		memset(&sa, 0, sizeof(sa));
		sa.sa_flags = SA_SIGINFO|SA_ONSTACK|SA_RESTART;
		sa.sa_mask = sigset_all;
		sa.sa_sigaction = handler;
		sigaction(i, &sa, NULL);
	}

	atomic_inc_uint(&ready);
	while (atomic_add_int_nv(&forked, 0) == 0)
		sched_yield();
	atomic_dec_uint_nv(&ready);

	/*
	 * Wait for all threads to acknowledge being ready before we
	 * call __fork, so there'll be no more calls to malloc -- we're
	 * skipping the malloc prefork/postfork actions (and all other
	 * pthread_atfork actions).
	 */
	while (atomic_add_int_nv(&ready, 0) != 0)
		sched_yield();

	for (;;) {
		volatile int x = 0;
		x++;
		pid = __fork();
		if (--x)
			_exit(127);
		switch (pid) {
		case -1:	/* error */
			err(1, "fork");
		case 0:		/* child */
			_exit(0);
		default:	/* parent */
			break;
		}
		if (wait4(pid, NULL, 0, NULL) == -1)
			err(1, "wait4");
	}
}

int
main(void)
{
	pthread_t t;
	unsigned n = 100;
	int error;

	sigfillset(&sigset_all);

	while (n --> 0) {
		error = pthread_create(&t, NULL, &start, (void *)(uintptr_t)n);
		if (error)
			errc(1, error, "pthread_create");
	}

	while (atomic_add_int_nv(&ready, 0) != 100)
		sched_yield();
	atomic_inc_uint(&forked);

	(void)pthread_join(t, NULL);
	return 0;
}