 @@ -1,14 +1,14 @@
-/* $NetBSD: clock.c,v 1.25 2012/01/14 21:42:51 reinoud Exp $ */
+/* $NetBSD: clock.c,v 1.26 2012/01/21 22:09:56 reinoud Exp $ */
 /*-
  * Copyright (c) 2007 Jared D. McNeill <jmcneill@invisible.ca>
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -19,130 +19,120 @@
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include "opt_hz.h"
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: clock.c,v 1.25 2012/01/14 21:42:51 reinoud Exp $");
+__KERNEL_RCSID(0, "$NetBSD: clock.c,v 1.26 2012/01/21 22:09:56 reinoud Exp $");
 #include <sys/param.h>
 #include <sys/proc.h>
 #include <sys/systm.h>
 #include <sys/device.h>
 #include <sys/lwp.h>
 #include <sys/cpu.h>
 #include <sys/malloc.h>
 #include <sys/timetc.h>
 #include <sys/time.h>
 #include <machine/pcb.h>
 #include <machine/mainbus.h>
 #include <machine/thunk.h>
 #include <dev/clock_subr.h>
 static int	clock_match(device_t, cfdata_t, void *);
 static void	clock_attach(device_t, device_t, void *);
 static void	clock_signal(int sig, siginfo_t *info, void *ctx);
 static unsigned int clock_getcounter(struct timecounter *);
 static int	clock_todr_gettime(struct todr_chip_handle *, struct timeval *);
 extern void setup_clock_intr(void);
 void clock_intr(void *priv);
 struct clock_softc {
 	device_t		sc_dev;
 	struct todr_chip_handle	sc_todr;
 };
 static struct timecounter clock_timecounter = {
 	clock_getcounter,	/* get_timecount */
 ,			/* no poll_pps */
 	~0u,			/* counter_mask */
 	1000000000ULL,		/* frequency */
 	"CLOCK_MONOTONIC",	/* name */
 	-100,			/* quality */
 	NULL,			/* prev */
 	NULL,			/* next */
 };
 timer_t clock_timerid;
 int clock_running = 0;
 CFATTACH_DECL_NEW(clock, sizeof(struct clock_softc),
     clock_match, clock_attach, NULL, NULL);
 static int
 clock_match(device_t parent, cfdata_t match, void *opaque)
+{
 	struct thunkbus_attach_args *taa = opaque;
 	if (taa->taa_type != THUNKBUS_TYPE_CLOCK)
 		return 0;
 	return 1;
+}
 static void
 clock_attach(device_t parent, device_t self, void *opaque)
+{
 	static struct sigaction sa;
 	struct clock_softc *sc = device_private(self);
 	aprint_naive("\n");
 	aprint_normal("\n");
 	sc->sc_dev = self;
 	sc->sc_todr.todr_gettime = clock_todr_gettime;
 	todr_attach(&sc->sc_todr);
 	memset(&sa, 0, sizeof(sa));
 	thunk_sigemptyset(&sa.sa_mask);
 	sa.sa_sigaction = clock_signal;
 	sa.sa_flags = SA_RESTART | SA_ONSTACK;
 	if (thunk_sigaction(SIGALRM, &sa, NULL) == -1)
 		panic("couldn't register SIGALRM handler : %d",
 		    thunk_geterrno());
 	clock_timerid = thunk_timer_attach();
 	clock_timecounter.tc_quality = 1000;
 	tc_init(&clock_timecounter);
 	setup_clock_intr();
 	clock_running = 1;
+}
-static void
+void
 clock_intr(void *priv)
+{
 	struct clockframe cf;
 	int nticks = thunk_timer_getoverrun(clock_timerid) + 1;
 	while (nticks-- > 0) {
 		hardclock(&cf);
+	}
+}
 static void
 clock_signal(int sig, siginfo_t *info, void *ctx)
 	curcpu()->ci_idepth++;
 	spl_intr(IPL_SOFTCLOCK, clock_intr, NULL);
 	curcpu()->ci_idepth--;
 static unsigned int
 clock_getcounter(struct timecounter *tc)
+{
 	return thunk_getcounter();
+}
 static int
 clock_todr_gettime(struct todr_chip_handle *tch, struct timeval *tv)
+{
 	struct thunk_timeval ttv;
 	int error;

 @@ -1,14 +1,14 @@
-/* $NetBSD: cpu.c,v 1.68 2012/01/18 19:17:02 reinoud Exp $ */
+/* $NetBSD: cpu.c,v 1.69 2012/01/21 22:09:56 reinoud Exp $ */
 /*-
  * Copyright (c) 2007 Jared D. McNeill <jmcneill@invisible.ca>
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -20,27 +20,27 @@
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include "opt_cpu.h"
 #include "opt_hz.h"
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: cpu.c,v 1.68 2012/01/18 19:17:02 reinoud Exp $");
+__KERNEL_RCSID(0, "$NetBSD: cpu.c,v 1.69 2012/01/21 22:09:56 reinoud Exp $");
 #include <sys/param.h>
 #include <sys/conf.h>
 #include <sys/proc.h>
 #include <sys/systm.h>
 #include <sys/device.h>
 #include <sys/reboot.h>
 #include <sys/lwp.h>
 #include <sys/cpu.h>
 #include <sys/mbuf.h>
 #include <sys/msgbuf.h>
 #include <sys/kmem.h>
 #include <sys/kernel.h>
 @@ -234,32 +234,33 @@ cpu_switchto(lwp_t *oldlwp, lwp_t *newlw
 	if (newpcb) {
 		thunk_printf_debug("    newpcb uc_link=%p, uc_stack.ss_sp=%p, "
 		    "uc_stack.ss_size=%d\n",
 		    newpcb->pcb_ucp.uc_link,
 		    newpcb->pcb_ucp.uc_stack.ss_sp,
 		    (int)newpcb->pcb_ucp.uc_stack.ss_size);
+	}
 #endif /* !CPU_DEBUG */
 	/* create atomic switcher */
 	thunk_makecontext(&sc->sc_ucp, (void (*)(void)) cpu_switchto_atomic,
 , oldlwp, newlwp, NULL);
-	if (!oldpcb) {
+	KASSERT(sc);
-		thunk_setcontext(&sc->sc_ucp);
+	if (oldpcb) {
 		/* never returns */
 	} else {
 		thunk_swapcontext(&oldpcb->pcb_ucp, &sc->sc_ucp);
 		/* returns here */
 	} else {
 		thunk_setcontext(&sc->sc_ucp);
 		/* never returns */
+	}
 #ifdef CPU_DEBUG
 	thunk_printf_debug("cpu_switchto: returning %p (was %p)\n", ci->ci_stash, oldlwp);
 #endif
 	return ci->ci_stash;
+}
 void
 cpu_dumpconf(void)
+{
 #ifdef CPU_DEBUG
 	thunk_printf_debug("cpu_dumpconf\n");
 @@ -364,28 +365,30 @@ cpu_lwp_fork(struct lwp *l1, struct lwp
 	/* copy the PCB and its switchframes from parent */
 	memcpy(pcb2, pcb1, sizeof(struct pcb));
 	/* refresh context */
 	if (thunk_getcontext(&pcb2->pcb_ucp))
 		panic("getcontext failed");
 	/* recalculate the system stack top */
 	pcb2->sys_stack_top = pcb2->sys_stack + TRAPSTACKSIZE;
 	/* get l2 its own stack */
 	pcb2->pcb_ucp.uc_stack.ss_sp = pcb2->sys_stack;
 	pcb2->pcb_ucp.uc_stack.ss_size = pcb2->sys_stack_top - pcb2->sys_stack;
 	pcb2->pcb_ucp.uc_flags = _UC_STACK | _UC_CPU | _UC_SIGMASK;
 	pcb2->pcb_ucp.uc_link = &pcb2->pcb_userret_ucp;
 	thunk_sigemptyset(&pcb2->pcb_ucp.uc_sigmask);
 	pcb2->pcb_ucp.uc_flags = _UC_STACK | _UC_CPU | _UC_SIGMASK;
 	thunk_makecontext(&pcb2->pcb_ucp,
 	    (void (*)(void)) cpu_lwp_trampoline,
 , &pcb2->pcb_ucp, func, arg);
+}
 void
 cpu_initclocks(void)
+{
 	extern timer_t clock_timerid;
 	thunk_timer_start(clock_timerid, HZ);
+}
 @@ -402,27 +405,29 @@ cpu_startup(void)
 	initmsgbuf(um_msgbuf, msgbufsize);
 	/* allocate a submap for physio, 1Mb enough? */
 	minaddr = 0;
 	phys_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
 * 1024, 0, false, NULL);
 	/* say hi! */
 	banner();
 	/* init lwp0 */
 	memset(&lwp0pcb, 0, sizeof(lwp0pcb));
 	thunk_getcontext(&lwp0pcb.pcb_ucp);
 	thunk_sigemptyset(&lwp0pcb.pcb_ucp.uc_sigmask);
 	lwp0pcb.pcb_ucp.uc_flags = _UC_STACK | _UC_CPU | _UC_SIGMASK;
 	uvm_lwp_setuarea(&lwp0, (vaddr_t) &lwp0pcb);
 	memcpy(&lwp0pcb.pcb_userret_ucp, &lwp0pcb.pcb_ucp, sizeof(ucontext_t));
 	/* set stack top */
 	lwp0pcb.sys_stack_top = lwp0pcb.sys_stack + TRAPSTACKSIZE;
+}
 void
 cpu_rootconf(void)
+{
 	extern char *usermode_root_device;
 	device_t rdev;

 @@ -1,14 +1,14 @@
-/* $NetBSD: ld_thunkbus.c,v 1.29 2012/01/09 21:01:31 reinoud Exp $ */
+/* $NetBSD: ld_thunkbus.c,v 1.30 2012/01/21 22:09:57 reinoud Exp $ */
 /*-
  * Copyright (c) 2011 Jared D. McNeill <jmcneill@invisible.ca>
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -17,27 +17,27 @@
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ld_thunkbus.c,v 1.29 2012/01/09 21:01:31 reinoud Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ld_thunkbus.c,v 1.30 2012/01/21 22:09:57 reinoud Exp $");
 #include <sys/param.h>
 #include <sys/proc.h>
 #include <sys/systm.h>
 #include <sys/device.h>
 #include <sys/buf.h>
 #include <sys/disk.h>
 #include <sys/kmem.h>
 #include <dev/ldvar.h>
 #include <machine/mainbus.h>
 #include <machine/thunk.h>
 @@ -135,29 +135,27 @@ ld_thunkbus_attach(device_t parent, devi
 	sc->busy = false;
 	ldattach(ld);
+}
 #ifdef LD_USE_AIO
 static int
 ld_aio_sig(void *arg)
+{
 	struct ld_softc *ld = arg;
 	struct ld_thunkbus_softc *sc = (struct ld_thunkbus_softc *)ld;
-	curcpu()->ci_idepth++;
+	softint_schedule(sc->sc_ih);
 	spl_intr(IPL_BIO, softint_schedule, sc->sc_ih);
 	curcpu()->ci_idepth--;
 	return 0;
+}
 static int
 ld_thunkbus_ldstart(struct ld_softc *ld, struct buf *bp)
+{
 	struct ld_thunkbus_softc *sc = (struct ld_thunkbus_softc *)ld;
 	struct ld_thunkbus_transfer *tt = &sc->sc_tt;
 	off_t offset = bp->b_rawblkno * ld->sc_secsize;
 	off_t disksize = ld->sc_secsize * ld->sc_secperunit;
 	int error;
 @@ -240,27 +238,27 @@ ld_thunkbus_complete(void *arg)
 static int
 ld_thunkbus_ldstart(struct ld_softc *ld, struct buf *bp)
+{
 	struct ld_thunkbus_softc *sc = (struct ld_thunkbus_softc *)ld;
 	struct ld_thunkbus_transfer *tt = &sc->sc_tt;
 	tt->tt_sc = sc;
 	tt->tt_bp = bp;
 	/* let the softint do the work */
 	sc->busy = true;
-	spl_intr(IPL_BIO, softint_schedule, sc->sc_ih);
+	softint_schedule(sc->sc_ih);
 	return 0;
+}
 static void
 ld_thunkbus_complete(void *arg)
+{
 	struct ld_softc *ld = arg;
 	struct ld_thunkbus_softc *sc = (struct ld_thunkbus_softc *)ld;
 	struct ld_thunkbus_transfer *tt = &sc->sc_tt;
 	struct buf *bp = tt->tt_bp;
 	off_t offset = bp->b_rawblkno * ld->sc_secsize;
 	int64_t ret;

 @@ -1,14 +1,14 @@
-/* $NetBSD: ttycons.c,v 1.17 2011/12/27 20:59:45 jmcneill Exp $ */
+/* $NetBSD: ttycons.c,v 1.18 2012/01/21 22:09:57 reinoud Exp $ */
 /*-
  * Copyright (c) 2007 Jared D. McNeill <jmcneill@invisible.ca>
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -17,27 +17,27 @@
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ttycons.c,v 1.17 2011/12/27 20:59:45 jmcneill Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ttycons.c,v 1.18 2012/01/21 22:09:57 reinoud Exp $");
 #include <sys/param.h>
 #include <sys/conf.h>
 #include <sys/proc.h>
 #include <sys/systm.h>
 #include <sys/device.h>
 #include <sys/kauth.h>
 #include <sys/termios.h>
 #include <sys/tty.h>
 #include <dev/cons.h>
 #include <machine/mainbus.h>
 @@ -93,29 +93,29 @@ const struct cdevsw ttycons_cdevsw = {
 	.d_stop = ttycons_stop,
 	.d_tty = ttycons_tty,
 	.d_poll = ttycons_poll,
 	.d_kqfilter = ttykqfilter,
 	.d_flag = D_TTY,
 };
 static void	ttycons_start(struct tty *);
 static int	ttycons_param(struct tty *, struct termios *);
 static int	ttycons_intr(void *);
 static void	ttycons_softintr(void *);
-static void	ttycons_ctrlc(int);
+static sigfunc_t  ttycons_ctrlc;
 static void	ttycons_softctrlc(void *);
-static void	ttycons_ctrlz(int);
+static sigfunc_t  ttycons_ctrlz;
 static void	ttycons_softctrlz(void *);
 static int
 ttycons_match(device_t parent, cfdata_t match, void *opaque)
+{
 	struct thunkbus_attach_args *taa = opaque;
 	if (taa->taa_type != THUNKBUS_TYPE_TTYCONS)
 		return 0;
 	return 1;
+}
 @@ -144,28 +144,29 @@ ttycons_attach(device_t parent, device_t
 	if (sc->sc_rd_sih == NULL)
 		panic("couldn't establish ttycons intr handler\n");
 	sc->sc_ctrlc_sih = softint_establish(SOFTINT_SERIAL,
 	    ttycons_softctrlc, sc);
 	if (sc->sc_ctrlc_sih == NULL)
 		panic("couldn't establish ttycons ctrlc handler\n");
 	sc->sc_ctrlz_sih = softint_establish(SOFTINT_SERIAL,
 	    ttycons_softctrlz, sc);
 	if (sc->sc_ctrlz_sih == NULL)
 		panic("couldn't establish ttycons ctrlz handler\n");
 	sigio_intr_establish(ttycons_intr, sc);
-	thunk_signal(SIGINT, ttycons_ctrlc);
+	signal_intr_establish(SIGINT,  ttycons_ctrlc);
-	thunk_signal(SIGTSTP, ttycons_ctrlz);
+	signal_intr_establish(SIGTSTP, ttycons_ctrlz);
 	if (thunk_set_stdin_sigio(true) != 0)
 		panic("couldn't enable stdin async mode");
+}
 void
 ttycons_consinit(void)
+{
 	struct thunk_termios t;
 	thunk_tcgetattr(0, &t);
 	t.c_lflag &= ~(ECHO|ICANON);
 	t.c_cc[VTIME] = 0;
 	t.c_cc[VMIN] = 1;
 @@ -351,84 +352,86 @@ static int
 ttycons_param(struct tty *t, struct termios *c)
+{
 	t->t_ispeed = c->c_ispeed;
 	t->t_ospeed = c->c_ospeed;
 	t->t_cflag = c->c_cflag;
 	return 0;
+}
 static int
 ttycons_intr(void *priv)
+{
 	struct ttycons_softc *sc = priv;
-	curcpu()->ci_idepth++;
+	softint_schedule(sc->sc_rd_sih);
 	spl_intr(IPL_SERIAL, softint_schedule, sc->sc_rd_sih);
 	curcpu()->ci_idepth--;
 	return 0;
+}
 static void
 ttycons_softintr(void *priv)
+{
 	struct ttycons_softc *sc = priv;
 	struct tty *t = sc->sc_tty;
 	unsigned char ch;
 	int c;
 	while ((c = thunk_pollchar()) >= 0) {
 		ch = (unsigned char)c;
 		cn_check_magic(t->t_dev, ch, ttycons_cnm_state);
 		t->t_linesw->l_rint(ch, t);
+	}
+}
 /*
  * handle SIGINT signal from trap.c
+ *
  * argument 'pc' and 'va' are not used.
  */
 static void
-ttycons_ctrlc(int sig)
+ttycons_ctrlc(vaddr_t from_userland, vaddr_t pc, vaddr_t va)
+{
 	struct ttycons_softc *sc;
 	curcpu()->ci_idepth++;
 	sc = device_lookup_private(&ttycons_cd, minor(cn_tab->cn_dev));
-	if (sc) {
+	if (sc)
-		spl_intr(IPL_SERIAL, softint_schedule, sc->sc_ctrlc_sih);
+		softint_schedule(sc->sc_ctrlc_sih);
 	curcpu()->ci_idepth--;
+}
 static void
 ttycons_softctrlc(void *priv)
+{
 	struct ttycons_softc *sc = priv;
 	struct tty *t = sc->sc_tty;
 	unsigned char ch = 3;	/* ETX */
 	cn_check_magic(t->t_dev, ch, ttycons_cnm_state);
 	t->t_linesw->l_rint(ch, t);
+}
 /*
  * handle SIGTSTP signal from trap.c
+ *
  * argument 'pc' and 'va' are not used.
  */
 static void
-ttycons_ctrlz(int sig)
+ttycons_ctrlz(vaddr_t from_userland, vaddr_t pc, vaddr_t va)
+{
 	struct ttycons_softc *sc;
 	curcpu()->ci_idepth++;
 	sc = device_lookup_private(&ttycons_cd, minor(cn_tab->cn_dev));
-	if (sc) {
+	if (sc)
-		spl_intr(IPL_SERIAL, softint_schedule, sc->sc_ctrlz_sih);
+		softint_schedule(sc->sc_ctrlz_sih);
 	curcpu()->ci_idepth--;
+}
 static void
 ttycons_softctrlz(void *priv)
+{
 	struct ttycons_softc *sc = priv;
 	struct tty *t = sc->sc_tty;
 	unsigned char ch = 26;	/* SUB */
 	cn_check_magic(t->t_dev, ch, ttycons_cnm_state);
 	t->t_linesw->l_rint(ch, t);
+}

 @@ -1,14 +1,14 @@
-/* $NetBSD: intr.c,v 1.14 2012/01/09 22:20:53 reinoud Exp $ */
+/* $NetBSD: intr.c,v 1.15 2012/01/21 22:09:57 reinoud Exp $ */
 /*-
  * Copyright (c) 2011 Jared D. McNeill <jmcneill@invisible.ca>
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -17,162 +17,46 @@
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: intr.c,v 1.14 2012/01/09 22:20:53 reinoud Exp $");
+__KERNEL_RCSID(0, "$NetBSD: intr.c,v 1.15 2012/01/21 22:09:57 reinoud Exp $");
 #include <sys/types.h>
 #include <machine/intr.h>
 #include <machine/thunk.h>
-struct intr_handler {
+int usermode_x = IPL_NONE;
 	int (*func)(void *);
 	void *arg;
 };
 #define SIGIO_MAX_HANDLERS	8
 static struct intr_handler sigio_intr_handler[SIGIO_MAX_HANDLERS];
 //#define INTR_USE_SIGPROCMASK
 #define MAX_QUEUED_EVENTS 128
 static int usermode_x = IPL_NONE;
 #ifdef INTR_USE_SIGPROCMASK
 static bool block_sigalrm = false;
 #endif
 struct spl_intr_event {
 	void (*func)(void *);
 	void *arg;
 };
 struct spl_intr_event spl_intrs[IPL_HIGH+1][MAX_QUEUED_EVENTS];
 int spl_intr_wr[IPL_HIGH+1];
 int spl_intr_rd[IPL_HIGH+1];
 void
 splinit(void)
+{
-	int i;
+	/* nothing */
 	for (i = 0; i <= IPL_HIGH; i++) {
 		spl_intr_rd[i] = 1;
 		spl_intr_wr[i] = 1;
 void
 spl_intr(int x, void (*func)(void *), void *arg)
 	struct spl_intr_event *spli;
 	if (x >= usermode_x) {
 		func(arg);
 		return;
 //	dprintf_debug("spl_intr: queue %d when %d\n", x, usermode_x);
 	spli = &spl_intrs[x][spl_intr_wr[x]];
 	spli->func = func;
 	spli->arg = arg;
 	spl_intr_wr[x] = (spl_intr_wr[x] + 1) % MAX_QUEUED_EVENTS;
 	if (spl_intr_wr[x] == spl_intr_rd[x]) {
 		thunk_printf("%s: spl list %d full!\n", __func__, x);
 		panic("%s: spl list %d full!\n", __func__, x);
+}
 int
 splraise(int x)
+{
 	int oldx = usermode_x;
-	if (x > usermode_x) {
+	if (x > usermode_x)
 		usermode_x = x;
 #ifdef INTR_USE_SIGPROCMASK
 	if (x >= IPL_SCHED && !block_sigalrm) {
 		thunk_sigblock(SIGALRM);
 		block_sigalrm = true;
 #endif
 	return oldx;
+}
 void
 spllower(int x)
+{
-	struct spl_intr_event *spli;
+	if (usermode_x > x)
 	int y;
 	/* `eat' interrupts that came by until we got back to x */
 	if (usermode_x > x) {
 //restart:
 		for (y = usermode_x; y >= x; y--) {
 			while (spl_intr_rd[y] != spl_intr_wr[y]) {
 //				dprintf_debug("spl y %d firing\n", y);
 				spli = &spl_intrs[y][spl_intr_rd[y]];
 				if (!spli->func)
 					panic("%s: spli->func is NULL for ipl %d, rd %d, wr %d\n",
 						__func__, y, spl_intr_rd[y], spl_intr_wr[y]);
 				spli->func(spli->arg);
 				spl_intr_rd[y] = (spl_intr_rd[y] + 1) % MAX_QUEUED_EVENTS;
 //				goto restart;
 		usermode_x = x;
 #ifdef INTR_USE_SIGPROCMASK
 	if (x < IPL_SCHED && block_sigalrm) {
 		thunk_sigunblock(SIGALRM);
 		block_sigalrm = false;
 #endif
+}
 void
 sigio_signal_handler(int sig, siginfo_t *info, void *ctx)
 	struct intr_handler *sih;
 	unsigned int n;
 	for (n = 0; n < SIGIO_MAX_HANDLERS; n++) {
 		sih = &sigio_intr_handler[n];
 		if (sih->func)
 			sih->func(sih->arg);
 void *
 sigio_intr_establish(int (*func)(void *), void *arg)
 	struct intr_handler *sih;
 	unsigned int n;
 	for (n = 0; n < SIGIO_MAX_HANDLERS; n++) {
 		sih = &sigio_intr_handler[n];
 		if (sih->func == NULL) {
 			sih->func = func;
 			sih->arg = arg;
 			return sih;
 	panic("increase SIGIO_MAX_HANDLERS");

 @@ -1,14 +1,14 @@
-/* $NetBSD: trap.c,v 1.60 2012/01/18 12:39:45 reinoud Exp $ */
+/* $NetBSD: trap.c,v 1.61 2012/01/21 22:09:57 reinoud Exp $ */
 /*-
  * Copyright (c) 2011 Reinoud Zandijk <reinoud@netbsd.org>
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -17,142 +17,211 @@
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: trap.c,v 1.60 2012/01/18 12:39:45 reinoud Exp $");
+__KERNEL_RCSID(0, "$NetBSD: trap.c,v 1.61 2012/01/21 22:09:57 reinoud Exp $");
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/systm.h>
 #include <sys/userret.h>
 #include <sys/kauth.h>
 #include <sys/errno.h>
 #include <uvm/uvm_extern.h>
 #include <machine/cpu.h>
 #include <machine/pcb.h>
 #include <machine/pmap.h>
 #include <machine/machdep.h>
 #include <machine/intr.h>
 #include <machine/thunk.h>
 /* define maximum signal number */
 #ifndef NSIG
 #define NSIG 64
 #endif
 /* forwards and externals */
 void setup_signal_handlers(void);
 void stop_all_signal_handlers(void);
-static void mem_access_handler(int sig, siginfo_t *info, void *ctx);
+static sigfunc_t pagefault;
-static void illegal_instruction_handler(int sig, siginfo_t *info, void *ctx);
+static sigfunc_t illegal_instruction;
-extern int errno;
+static sigfunc_t alarm;
 static sigfunc_t sigio;
 /* raw signal handlers */
 static stack_t sigstk;
 ucontext_t jump_ucp;
-static void pagefault(vaddr_t from_userland, vaddr_t pc, vaddr_t va);
+sigfunc_t *sig_funcs[NSIG];
 static void illegal_instruction(vaddr_t from_userland);
-bool pmap_fault(pmap_t pmap, vaddr_t va, vm_prot_t *atype);
+/* segv, bus */
 extern bool pmap_fault(pmap_t pmap, vaddr_t va, vm_prot_t *atype);
-static stack_t sigstk;
+/* alarm */
 void setup_clock_intr(void);
 extern void clock_intr(void *priv);
 extern int clock_running;
 void *alrm_ih;
 /* sigio handlers */
 struct intr_handler {
 	int (*func)(void *);
 	void *arg;
 };
 #define SIGIO_MAX_HANDLERS	8
 static struct intr_handler sigio_intr_handler[SIGIO_MAX_HANDLERS];
 /* misc */
 int astpending = 0;
 /* XXX why is it here ? */
 void
 startlwp(void *arg)
+{
 	/* nothing here */
+}
 void
 setup_signal_handlers(void)
+{
-	static struct sigaction sa;
+	int i;
 	/*
 	 * Set up the alternative signal stack. This prevents signals to be
 	 * pushed on the NetBSD/usermode userland's stack with all desastrous
 	 * effects. Especially ld.so and friends have such tiny stacks that
 	 * its not feasable.
 	 */
 	if ((sigstk.ss_sp = thunk_malloc(SIGSTKSZ)) == NULL)
 		panic("can't allocate signal stack space\n");
 	sigstk.ss_size  = SIGSTKSZ;
 	sigstk.ss_flags = 0;
 	if (thunk_sigaltstack(&sigstk, 0) < 0)
 		panic("can't set alternate stacksize: %d",
 		    thunk_geterrno());
-	/* SIGBUS and SIGSEGV need to be reentrant hence the SA_NODEFER */
+	for (i = 0; i < NSIG; i++)
-	sa.sa_flags = SA_RESTART | SA_SIGINFO | SA_ONSTACK | SA_NODEFER;
+		sig_funcs[i] = NULL;
 	sa.sa_sigaction = mem_access_handler;
 	thunk_sigemptyset(&sa.sa_mask);
 	if (thunk_sigaction(SIGSEGV, &sa, NULL) == -1)
 		panic("couldn't register SIGSEGV handler: %d",
 		    thunk_geterrno());
 	if (thunk_sigaction(SIGBUS, &sa, NULL) == -1)
 		panic("couldn't register SIGBUS handler: %d", thunk_geterrno());
 	sa.sa_flags = SA_RESTART | SA_SIGINFO | SA_ONSTACK;
 	sa.sa_sigaction = illegal_instruction_handler;
 	thunk_sigemptyset(&sa.sa_mask);
 	if (thunk_sigaction(SIGILL, &sa, NULL) == -1)
 		panic("couldn't register SIGILL handler: %d", thunk_geterrno());
-	sa.sa_flags = SA_RESTART | SA_SIGINFO | SA_ONSTACK;
+	/* HUP */
-	sa.sa_sigaction = sigio_signal_handler;
+	/* INT */	/* ttycons ^C */
-	thunk_sigemptyset(&sa.sa_mask);
+	/* QUIT */
-	if (thunk_sigaction(SIGIO, &sa, NULL) == -1)
+	signal_intr_establish(SIGILL, illegal_instruction);
-		panic("couldn't register SIGIO handler: %d", thunk_geterrno());
+	/* TRAP */
 	/* ABRT */
 	/* SIGEMT */
 	/* SIGFPE XXX! */
 	/* KILL */
 	signal_intr_establish(SIGBUS,  pagefault);
 	signal_intr_establish(SIGSEGV, pagefault);
 	/* SYS */
 	/* PIPE */
 	signal_intr_establish(SIGALRM, alarm);
 	/* TERM */
 	/* URG */
 	/* STOP */
 	/* TSTP */	/* ttycons ^Z */
 	/* CONT */
 	/* CHLD */
 	/* GTTIN */
 	/* TTOU */
 	signal_intr_establish(SIGIO,   sigio);
 	/* XCPU */
 	/* XFSZ */
 	/* VTALRM */
 	/* PROF */
 	/* WINCH */
 	/* INFO */
 	/* USR1 */
 	/* USR2 */
 	/* PWR */
+}
 /* XXX yes this is blunt */
 void
 stop_all_signal_handlers(void)
+{
-	thunk_sigblock(SIGALRM);
+	int i;
-	thunk_sigblock(SIGIO);
+	for (i = 0; i < NSIG; i++)
-	thunk_sigblock(SIGILL);
+		if (sig_funcs[i])
-	thunk_sigblock(SIGSEGV);
+			thunk_sigblock(i);
 	thunk_sigblock(SIGBUS);
+}
 /* ast and userret */
 void
-userret(struct lwp *l)
+setup_clock_intr(void)
+{
-	/* invoke MI userret code */
+	/* setup soft interrupt handler */
-	mi_userret(l);
+	alrm_ih = softint_establish(SOFTINT_CLOCK,
 		clock_intr, NULL);
+}
 /* ast and userret */
 static void
 ast(struct lwp *l)
+{
 	struct pcb *pcb;
-	while (astpending) {
+	if (!astpending)
-		astpending = 0;
+		return;
 	astpending = 0;
 	curcpu()->ci_data.cpu_ntrap++;
 		curcpu()->ci_data.cpu_ntrap++;
 #if 0
-		/* profiling */
+	/* profiling */
-		if (l->l_pflag & LP_OWEUPC) {
+	if (l->l_pflag & LP_OWEUPC) {
-			l->l_pflag &= ~LP_OWEUPC;
+		l->l_pflag &= ~LP_OWEUPC;
-			ADDUPROF(l);
+		ADDUPROF(l);
+	}
 #endif
 		/* allow a forced task switch */
 		if (l->l_cpu->ci_want_resched)
 			preempt();
-		mi_userret(l);
+	/* allow a forced task switch */
 	if (curcpu()->ci_want_resched) {
 		curcpu()->ci_want_resched = 0;
 		preempt();
 		/* returns here! */
+	}
 	KASSERT(l == curlwp); KASSERT(l);
 	pcb = lwp_getpcb(l); KASSERT(pcb);
 	mi_userret(l);
+}
 void
 userret(struct lwp *l)
+{
 	/* invoke MI userret code */
 	mi_userret(l);
 	ast(l);
+}
 #ifdef DEBUG
 /*
  * Uncomment the following if you want to receive information about what
  * triggered the fault. Mainly for debugging and porting purposes
  */
 static void
 print_mem_access_siginfo(int sig, siginfo_t *info, void *ctx,
 	vaddr_t pc, vaddr_t va, vaddr_t sp)
+{
 #if 0
 @@ -165,31 +234,28 @@ print_mem_access_siginfo(int sig, siginf
 	if (info->si_code == SEGV_ACCERR)
 		thunk_printf_debug("\t\tSEGV_ACCERR\n");
 	if (info->si_code == BUS_ADRALN)
 		thunk_printf_debug("\t\tBUS_ADRALN\n");
 	if (info->si_code == BUS_ADRERR)
 		thunk_printf_debug("\t\tBUS_ADRERR\n");
 	if (info->si_code == BUS_OBJERR)
 		thunk_printf_debug("\t\tBUS_OBJERR\n");
 	thunk_printf_debug("\tsi_addr = %p\n", info->si_addr);
 	thunk_printf_debug("\tsi_trap = %d\n", info->si_trap);
 #endif
 #if 0
-	printf("memaccess error, pc %p, va %p, "
+	thunk_printf("memaccess error, pc %p, va %p, sp %p\n",
-		"sys_stack %p, sp %p, stack top %p\n",
+		(void *) pc, (void *) va, (void *) sp);
 		(void *) pc, (void *) va,
 		(void *) pcb->sys_stack, (void *) sp,
 		(void *) pcb->sys_stack_top);
 #endif
+}
 /*
  * Uncomment the following if you want to receive information about what
  * triggered the fault. Mainly for debugging and porting purposes
  */
 static void
 print_illegal_instruction_siginfo(int sig, siginfo_t *info, void *ctx,
 	vaddr_t pc, vaddr_t va, vaddr_t sp)
+{
 #if 0
 	thunk_printf("SIGILL!\n");
 @@ -210,155 +276,125 @@ print_illegal_instruction_siginfo(int si
 		thunk_printf("\t\tPrivileged register");
 	if (info->si_code == ILL_COPROC)
 		thunk_printf("\t\tCoprocessor error");
 	if (info->si_code == ILL_BADSTK)
 		thunk_printf("\t\tInternal stack error");
 	thunk_printf("\tsi_addr = %p\n", info->si_addr);
 	thunk_printf("\tsi_trap = %d\n", info->si_trap);
 	thunk_printf("%p : ", info->si_addr);
 	for (int i = 0; i < 10; i++)
 		thunk_printf("%02x ", *((uint8_t *) info->si_addr + i));
 	thunk_printf("\n");
 #endif
 #if 0
 	thunk_printf("sigill\n");
 #endif
+}
 #else /* DEBUG */
 #define print_mem_access_siginfo(s, i, c, p, v, sp)
 #define print_illegal_instruction_siginfo(s, i, c, p, v, sp)
 #endif /* DEBUG */
 /* signal handler switching to a pagefault context */
 static void
-mem_access_handler(int sig, siginfo_t *info, void *ctx)
+handle_signal(int sig, siginfo_t *info, void *ctx)
+{
 	sigfunc_t *f;
 	ucontext_t *ucp = ctx;
 	struct lwp *l;
 	struct pcb *pcb;
 	vaddr_t va, sp, pc, fp;
 	int from_userland;
-	assert((info->si_signo == SIGSEGV) || (info->si_signo == SIGBUS));
+	if (sig == SIGBUS || sig == SIGSEGV || sig == SIGILL) {
 		if (info->si_code == SI_NOINFO)
 			panic("received signal %d with no info",
 			    info->si_signo);
+	}
-	if (info->si_code == SI_NOINFO)
+	f = sig_funcs[sig];
-		panic("received signal %d with no info",
+	KASSERT(f);
 		    info->si_signo);
-	l = curlwp;
+	l = curlwp; KASSERT(l);
-	pcb = lwp_getpcb(l);
+	pcb = lwp_getpcb(l); KASSERT(pcb);
-	/* get address of faulted memory access and make it page aligned */
+	/* get address of possible faulted memory access and page aligne it */
 	va = (vaddr_t) info->si_addr;
 	va = trunc_page(va);
-	/* get PC address of faulted memory instruction */
+	/* get PC address of possibly faulted instruction */
 	pc = md_get_pc(ctx);
-	/* setup for pagefault context */
+	/* nest it on the stack */
 	sp = md_get_sp(ctx);
-	print_mem_access_siginfo(sig, info, ctx, pc, va, sp);
+	if (sig == SIGBUS || sig == SIGSEGV)
 		print_mem_access_siginfo(sig, info, ctx, pc, va, sp);
 	if (sig == SIGILL)
 		print_illegal_instruction_siginfo(sig, info, ctx, pc, va, sp);
 	/* if we're running on a stack of our own, use the system stack */
 	from_userland = 0;
-	if ((sp < (vaddr_t) pcb->sys_stack) || (sp > (vaddr_t) pcb->sys_stack_top)) {
+	if ((sp < (vaddr_t) pcb->sys_stack) ||
 	    (sp > (vaddr_t) pcb->sys_stack_top)) {
 		sp = (vaddr_t) pcb->sys_stack_top - sizeof(register_t);
 		fp = (vaddr_t) &pcb->pcb_userret_ucp;
 		if (pc < kmem_user_end)
 			from_userland = 1;
 	} else {
 		/* stack grows down */
 		fp = sp - sizeof(ucontext_t) - sizeof(register_t); /* slack */
 		sp = fp - sizeof(register_t);	/* slack */
 		/* sanity check before copying */
 		if (fp - 2*PAGE_SIZE < (vaddr_t) pcb->sys_stack)
 			panic("%s: out of system stack", __func__);
+	}
 	memcpy((void *) fp, ucp, sizeof(ucontext_t));
 	memcpy(&jump_ucp, ucp, sizeof(ucontext_t));
-	/* create context for pagefault */
+	/* create context */
-	pcb->pcb_ucp.uc_stack.ss_sp = (void *) pcb->sys_stack;
+	jump_ucp.uc_stack.ss_sp = (void *) pcb->sys_stack;
-	pcb->pcb_ucp.uc_stack.ss_size = sp - (vaddr_t) pcb->sys_stack;
+	jump_ucp.uc_stack.ss_size = sp - (vaddr_t) pcb->sys_stack;
-	pcb->pcb_ucp.uc_link = (void *) fp;	/* link to old frame on stack */
+	jump_ucp.uc_link = (void *) fp;	/* link to old frame on stack */
-	pcb->pcb_ucp.uc_flags = _UC_STACK | _UC_CPU;
+	thunk_sigemptyset(&jump_ucp.uc_sigmask);
-	thunk_makecontext(&pcb->pcb_ucp, (void (*)(void)) pagefault,
+	jump_ucp.uc_flags = _UC_STACK | _UC_CPU | _UC_SIGMASK;
 	thunk_makecontext(&jump_ucp,
 			(void (*)(void)) f,
 , (void *) from_userland, (void *) pc, (void *) va);
-	/* switch to the new pagefault entry on return from signal */
+	/* switch to the new context on return from signal */
-	memcpy(ctx, &pcb->pcb_ucp, sizeof(ucontext_t));
+	thunk_setcontext(&jump_ucp);
 //	memcpy(ctx, &pcb->pcb_ucp, sizeof(ucontext_t));
+}
-/* signal handler switching to a illegal instruction context */
+void
-static void
+signal_intr_establish(int sig, sigfunc_t f)
 illegal_instruction_handler(int sig, siginfo_t *info, void *ctx)
+{
-	ucontext_t *ucp = ctx;
+	static struct sigaction sa;
 	struct lwp *l;
 	struct pcb *pcb;
 	vaddr_t sp, pc, fp;
 	int from_userland;
 	assert(info->si_signo == SIGILL);
 	l = curlwp;
 	pcb = lwp_getpcb(l);
 	/* get PC address of faulted instruction */
 	pc = md_get_pc(ctx);
 	/* setup for illegal_instruction context */
 	sp = md_get_sp(ctx);
 	print_illegal_instruction_siginfo(sig, info, ctx, pc, 0, sp);
 	/* if we're running on a stack of our own, use the system stack */
 	from_userland = 0;
 	if ((sp < (vaddr_t) pcb->sys_stack) ||
 			(sp > (vaddr_t) pcb->sys_stack_top)) {
 		sp = (vaddr_t) pcb->sys_stack_top - sizeof(register_t);
 		fp = (vaddr_t) &pcb->pcb_userret_ucp;
 		KASSERT(pc < kmem_user_end);
 		from_userland = 1;
 	} else {
 		panic("illegal instruction inside kernel?");
 #if 0
 		/* stack grows down */
 		fp = sp - sizeof(ucontext_t) - sizeof(register_t); /* slack */
 		sp = fp - sizeof(register_t);	/* slack */
 		/* sanity check before copying */
 		if (fp - 2*PAGE_SIZE < (vaddr_t) pcb->sys_stack)
 			panic("%s: out of system stack", __func__);
 #endif
 	memcpy((void *) fp, ucp, sizeof(ucontext_t));
-	/* create context for illegal instruction */
+	sig_funcs[sig] = f;
 	pcb->pcb_ucp.uc_stack.ss_sp = (void *) pcb->sys_stack;
 	pcb->pcb_ucp.uc_stack.ss_size = sp - (vaddr_t) pcb->sys_stack;
 	pcb->pcb_ucp.uc_link = (void *) fp;	/* link to old frame on stack */
 	pcb->pcb_ucp.uc_flags = _UC_STACK | _UC_CPU;
 	thunk_makecontext(&pcb->pcb_ucp, (void (*)(void)) illegal_instruction,
 , (void *) from_userland, NULL, NULL);
-	/* switch to the new illegal instruction entry on return from signal */
+	sa.sa_flags = SA_RESTART | SA_SIGINFO | SA_ONSTACK;
-	memcpy(ctx, &pcb->pcb_ucp, sizeof(ucontext_t));
+	sa.sa_sigaction = (void *) handle_signal;
 	thunk_sigfillset(&sa.sa_mask);
 	if (thunk_sigaction(sig, &sa, NULL) == -1)
 		panic("couldn't register SIG%d handler: %d", sig,
 		    thunk_geterrno());
+}
 /*
  * Context for handing page faults from the sigsegv handler; check if its a
  * pmap reference fault or let uvm handle it.
  */
 static void
 pagefault(vaddr_t from_userland, vaddr_t pc, vaddr_t va)
+{
 	struct proc *p;
 	struct lwp *l;
 	struct pcb *pcb;
 @@ -367,38 +403,37 @@ pagefault(vaddr_t from_userland, vaddr_t
 	vm_prot_t atype;
 	void *onfault;
 	int from_kernel, lwp_errno, error;
 	ksiginfo_t ksi;
 	l = curlwp; KASSERT(l);
 	pcb = lwp_getpcb(l);
 	p = l->l_proc;
 	vm = p->p_vmspace;
 	lwp_errno = thunk_geterrno();
 	vm_map = &vm->vm_map;
-	from_kernel = (pc >= kmem_k_start);
+	from_kernel = (pc >= kmem_k_start) && (!from_userland);
 	if (from_kernel && (va >= VM_MIN_KERNEL_ADDRESS))
 		vm_map = kernel_map;
 #if 0
-	thunk_printf("pagefault : pc %p, va %p\n",
+	thunk_printf("%s: l %p, pcb %p\n", __func__, l, pcb);
-		(void *) pc, (void *) va);
+	thunk_printf("\tpc %p, va %p\n", (void *) pc, (void *) va);
 #endif
 	/* can pmap handle it? on its own? (r/m) emulation */
 	if (pmap_fault(vm_map->pmap, va, &atype)) {
 //		thunk_printf("pagefault leave (pmap)\n");
 		/* no use doing anything else here */
 		goto out_quick;
+	}
 	/* ask UVM */
 	thunk_printf_debug("pmap fault couldn't handle it! : "
 		"derived atype %d\n", atype);
 	onfault = pcb->pcb_onfault;
 	pcb->pcb_onfault = NULL;
 	error = uvm_fault(vm_map, va, atype);
 	pcb->pcb_onfault = onfault;
 @@ -406,47 +441,48 @@ pagefault(vaddr_t from_userland, vaddr_t
 		if (error == 0)
 			uvm_grow(l->l_proc, va);
+	}
 	if (error == EACCES)
 		error = EFAULT;
 	/* if uvm handled it, return */
 	if (error == 0) {
 //		thunk_printf("pagefault leave (uvm)\n");
 		goto out;
+	}
 	/* something got wrong */
-	thunk_printf("%s: uvm fault %d, pc %p, from_kernel %d\n",
+	thunk_printf("%s: uvm fault %d, pc %p, va %p, from_kernel %d\n",
-		__func__, error, (void *) pc, from_kernel);
+		__func__, error, (void *) pc, (void *) va, from_kernel);
 	/* check if its from copyin/copyout */
 	if (onfault) {
 		panic("%s: can't call onfault yet\n", __func__);
 		/* XXX implement me ? */
 		/* jump to given onfault */
 		// tf = &kernel_tf;
 		// memset(tf, 0, sizeof(struct trapframe));
 		// tf->tf_pc = onfault;
 		// tf->tf_io[0] = (rv == EACCES) ? EFAULT : rv;
 		goto out;
+	}
 	if (from_kernel)
 		panic("Unhandled page fault in kernel mode");
 	/* send signal */
 	thunk_printf("giving signal to userland\n");
 	KASSERT(from_userland);
 	KSI_INIT_TRAP(&ksi);
 	ksi.ksi_signo = SIGSEGV;
 	ksi.ksi_trap = 0;	/* XXX */
 	ksi.ksi_code = (error == EPERM) ? SEGV_ACCERR : SEGV_MAPERR;
 	ksi.ksi_addr = (void *) va;
 	if (error == ENOMEM) {
 		printf("UVM: pid %d.%d (%s), uid %d killed: "
 		    "out of swap\n",
 		    p->p_pid, l->l_lid, p->p_comm,
 		    l->l_cred ? kauth_cred_geteuid(l->l_cred) : -1);
 		ksi.ksi_signo = SIGKILL;
+	}
 @@ -458,51 +494,123 @@ pagefault(vaddr_t from_userland, vaddr_t
 #endif
 //	thunk_printf("pagefault leave\n");
 out:
 	if (from_userland)
 		userret(l);
 out_quick:
 	thunk_seterrno(lwp_errno);
 	pcb->pcb_errno = lwp_errno;
+}
 /*
- * Context for handing illegal instruction from the sigill handler
+ * handle an illegal instruction.
+ *
  * arguments 'pc' and 'va' are ignored here
  */
 static void
-illegal_instruction(vaddr_t from_userland)
+illegal_instruction(vaddr_t from_userland, vaddr_t pc, vaddr_t va)
+{
 	struct lwp *l = curlwp;
 	struct pcb *pcb = lwp_getpcb(l);
 	ucontext_t *ucp = &pcb->pcb_userret_ucp;
 	ksiginfo_t ksi;
-//	thunk_printf("illegal instruction\n");
+//	thunk_printf("%s: l %p, pcb %p\n", __func__, l, pcb);
 	KASSERT(from_userland);
 	/* if its a syscall ... */
 	if (md_syscall_check_opcode(ucp)) {
 		syscall();
 //		thunk_printf("illegal instruction leave\n");
 		KASSERT(from_userland);
 		userret(l);
 		return;
+	}
 	thunk_printf("%s: giving SIGILL (TRAP)\n", __func__);
 	KASSERT(from_userland);
 	KSI_INIT_TRAP(&ksi);
 	ksi.ksi_signo = SIGILL;
 	ksi.ksi_trap  = 0;	/* XXX */
 	ksi.ksi_errno = 0; // info->si_errno;
 	ksi.ksi_code  = 0; // info->si_code;
 	ksi.ksi_addr  = (void *) md_get_pc(ucp); /* only relyable source */
 #if 0
 	p->p_emul->e_trapsignal(l, &ksi);
 #else
 	trapsignal(l, &ksi);
 #endif
 	KASSERT(from_userland);
 	userret(l);
+}
 /*
  * handle alarm, a clock ticker.
+ *
  * arguments 'pc' and 'va' are ignored here
  */
 static void
 alarm(vaddr_t from_userland, vaddr_t pc, vaddr_t va)
+{
 	struct lwp *l = curlwp;
 	struct pcb *pcb = lwp_getpcb(l); KASSERT(pcb);
 	if (!clock_running)
 		return;
 //	thunk_printf("%s: l %p, pcb %p\n", __func__, l, pcb);
 	softint_schedule(alrm_ih);
 	KASSERT(l == curlwp);
 	if (from_userland)
 		userret(l);
+}
 /*
  * handle sigio, a mux for all io operations.
+ *
  * arguments 'pc' and 'va' are ignored here
  */
 static void
 sigio(vaddr_t from_userland, vaddr_t pc, vaddr_t va)
+{
 	struct lwp *l = curlwp;
 	struct pcb *pcb = lwp_getpcb(l); KASSERT(pcb);
 	struct intr_handler *sih;
 	unsigned int n;
 //	thunk_printf("%s: l %p, pcb %p\n", __func__, l, pcb);
 	for (n = 0; n < SIGIO_MAX_HANDLERS; n++) {
 		sih = &sigio_intr_handler[n];
 		if (sih->func)
 			sih->func(sih->arg);
+	}
 	KASSERT(l == curlwp);
 	if (from_userland)
 		userret(l);		/* or ast? */
+}
 /* sigio register function */
 void *
 sigio_intr_establish(int (*func)(void *), void *arg)
+{
 	struct intr_handler *sih;
 	unsigned int n;
 	for (n = 0; n < SIGIO_MAX_HANDLERS; n++) {
 		sih = &sigio_intr_handler[n];
 		if (sih->func == NULL) {
 			sih->func = func;
 			sih->arg = arg;
 			return sih;
+		}
+	}
 	panic("increase SIGIO_MAX_HANDLERS");
+}

 @@ -1,14 +1,14 @@
-/* $NetBSD: intr.h,v 1.6 2011/12/26 22:04:35 jmcneill Exp $ */
+/* $NetBSD: intr.h,v 1.7 2012/01/21 22:09:57 reinoud Exp $ */
 /*-
  * Copyright (c) 2007 Jared D. McNeill <jmcneill@invisible.ca>
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -22,44 +22,51 @@
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #ifndef _ARCH_USERMODE_INCLUDE_INTR_H
 #define _ARCH_USERMODE_INCLUDE_INTR_H
 #include <machine/intrdefs.h>
 #include <sys/siginfo.h>
-void	sigio_signal_handler(int, siginfo_t *, void *);
+/* spl */
 void *	sigio_intr_establish(int (*)(void *), void *);
 void	splinit(void);
 int	splraise(int);
 void	spllower(int);
 void	spl_intr(int x, void (*func)(void *), void *arg);
 #define	spl0()		spllower(IPL_NONE)
 #define splx(x)		spllower(x)
 /* traps */
 typedef void (sigfunc_t)(vaddr_t from_userland, vaddr_t pc, vaddr_t va);
 extern void setup_signal_handlers(void);
 extern void  signal_intr_establish(int sig, sigfunc_t f);
 extern void *sigio_intr_establish(int (*)(void *), void *);
 /* spl implementation */
 typedef uint8_t ipl_t;
 typedef struct {
 	ipl_t _ipl;
 } ipl_cookie_t;
 static inline ipl_cookie_t
 makeiplcookie(ipl_t ipl)
+{
 	return (ipl_cookie_t){._ipl = ipl};
+}
 static inline int
 splraiseipl(ipl_cookie_t icookie)
+{
 	return splraise(icookie._ipl);
+}
 #include <sys/spl.h>
 /* for trap.c */
 #endif /* !_ARCH_USERMODE_INCLUDE_INTR_H */