reg_t di; /* di through cx are not accessed in C */
reg_t si; /* order is to match pusha/popa */
reg_t fp; /* bp */
- reg_t st; /* hole for another copy of sp */
+/* reg_t st; */ /* hole for another copy of sp */
reg_t bx; /* | */
reg_t dx; /* | */
reg_t cx; /* | */
reg_t retreg; /* ax and above are all pushed by save */
- reg_t retadr; /* return address for assembly code save() */
+/* reg_t retadr; */ /* return address for assembly code save() */
reg_t pc; /* ^ last item pushed by interrupt */
reg_t cs; /* | */
reg_t psw; /* | */
#include <assert.h>
#include <signal.h>
#include <machine/vm.h>
+#include <machine/signal.h>
#include <arm/armreg.h>
#include <minix/u64.h>
int isuser, int trapstyle)
{
assert(sizeof(p->p_reg) == sizeof(*state));
- memcpy(&p->p_reg, state, sizeof(*state));
+ if(state != &p->p_reg) {
+ memcpy(&p->p_reg, state, sizeof(*state));
+ }
/* further code is instructed to not touch the context
* any more
return p;
}
-void fpu_sigcontext(struct proc *pr, struct sigframe *fr, struct sigcontext *sc)
+void fpu_sigcontext(struct proc *pr, struct sigframe_sigcontext *fr, struct sigcontext *sc)
{
}
/* someone wants to totally re-initialize process state */
assert(sizeof(p->p_reg) == sizeof(*state));
- memcpy(&p->p_reg, state, sizeof(*state));
+ if(state != &p->p_reg) {
+ memcpy(&p->p_reg, state, sizeof(*state));
+ }
/* further code is instructed to not touch the context
* any more
NOT_REACHABLE;
}
-void fpu_sigcontext(struct proc *pr, struct sigframe *fr, struct sigcontext *sc)
+void fpu_sigcontext(struct proc *pr, struct sigframe_sigcontext *fr, struct sigcontext *sc)
{
int fp_error;
member DIREG p_reg.di
member SIREG p_reg.si
member BPREG p_reg.fp
-member STREG p_reg.st
member BXREG p_reg.bx
member DXREG p_reg.dx
member CXREG p_reg.cx
member AXREG p_reg.retreg
-member RETADR p_reg.retadr
member PCREG p_reg.pc
member CSREG p_reg.cs
member PSWREG p_reg.psw
movl (8 + displ)(%esp), tmp ;\
movl tmp, PSWREG(pptr) ;\
movl (12 + displ)(%esp), tmp ;\
- movl tmp, SPREG(pptr) ;\
- movl tmp, STREG(pptr)
+ movl tmp, SPREG(pptr)
/*
* restore kernel segments. %cs is already set and %fs, %gs are not used */
#include <minix/safecopies.h>
#include <machine/archtypes.h>
+#include <machine/signal.h>
+#include <machine/frame.h>
/* Struct declarations. */
struct proc;
int restore_fpu(struct proc *);
void save_fpu(struct proc *);
void save_local_fpu(struct proc *, int retain);
-void fpu_sigcontext(struct proc *, struct sigframe *fr, struct
+void fpu_sigcontext(struct proc *, struct sigframe_sigcontext *fr, struct
sigcontext *sc);
/* main.c */
#if defined(__i386__)
/* Restore user bits of psw from sc, maintain system bits from proc. */
- sc.sc_psw = (sc.sc_psw & X86_FLAGS_USER) |
+ sc.sc_eflags = (sc.sc_eflags & X86_FLAGS_USER) |
(rp->p_reg.psw & ~X86_FLAGS_USER);
#endif
#if defined(__i386__)
- /* Don't panic kernel if user gave bad selectors. */
- sc.sc_cs = rp->p_reg.cs;
- sc.sc_ds = rp->p_reg.ds;
- sc.sc_es = rp->p_reg.es;
- sc.sc_ss = rp->p_reg.ss;
- sc.sc_fs = rp->p_reg.fs;
- sc.sc_gs = rp->p_reg.gs;
+ /* Write back registers we allow to be restored, i.e.
+ * not the segment ones.
+ */
+ rp->p_reg.di = sc.sc_edi;
+ rp->p_reg.si = sc.sc_esi;
+ rp->p_reg.fp = sc.sc_ebp;
+ rp->p_reg.bx = sc.sc_ebx;
+ rp->p_reg.dx = sc.sc_edx;
+ rp->p_reg.cx = sc.sc_ecx;
+ rp->p_reg.retreg = sc.sc_eax;
+ rp->p_reg.pc = sc.sc_eip;
+ rp->p_reg.psw = sc.sc_eflags;
+ rp->p_reg.sp = sc.sc_esp;
+#endif
+
+#if defined(__arm__)
+ rp->p_reg.psr = sc.sc_spsr;
+ rp->p_reg.retreg = sc.sc_r0;
+ rp->p_reg.r1 = sc.sc_r1;
+ rp->p_reg.r2 = sc.sc_r2;
+ rp->p_reg.r3 = sc.sc_r3;
+ rp->p_reg.r4 = sc.sc_r4;
+ rp->p_reg.r5 = sc.sc_r5;
+ rp->p_reg.r6 = sc.sc_r6;
+ rp->p_reg.r7 = sc.sc_r7;
+ rp->p_reg.r8 = sc.sc_r8;
+ rp->p_reg.r9 = sc.sc_r9;
+ rp->p_reg.r10 = sc.sc_r10;
+ rp->p_reg.fp = sc.sc_r11;
+ rp->p_reg.r12 = sc.sc_r12;
+ rp->p_reg.sp = sc.sc_usr_sp;
+ rp->p_reg.lr = sc.sc_usr_lr;
+ rp->p_reg.pc = sc.sc_pc;
#endif
/* Restore the registers. */
- arch_proc_setcontext(rp, &sc.sc_regs, 1, sc.trap_style);
+ arch_proc_setcontext(rp, &rp->p_reg, 1, sc.trap_style);
+
+ if(sc.sc_magic != SC_MAGIC) { printf("kernel sigreturn: corrupt signal context\n"); }
+
#if defined(__i386__)
if (sc.sc_flags & MF_FPU_INITIALIZED)
{
struct sigmsg smsg;
register struct proc *rp;
- struct sigcontext sc, *scp;
- struct sigframe fr, *frp;
+ struct sigframe_sigcontext fr, *frp;
int proc_nr, r;
if (!isokendpt(m_ptr->m_sigcalls.endpt, &proc_nr)) return EINVAL;
(vir_bytes)&smsg, (phys_bytes) sizeof(struct sigmsg))) != OK)
return r;
- /* Compute the user stack pointer where sigcontext will be stored. */
+ /* Compute the user stack pointer where sigframe will start. */
smsg.sm_stkptr = arch_get_sp(rp);
- scp = (struct sigcontext *) smsg.sm_stkptr - 1;
+ frp = (struct sigframe_sigcontext *) smsg.sm_stkptr - 1;
/* Copy the registers to the sigcontext structure. */
- memcpy(&sc.sc_regs, (char *) &rp->p_reg, sizeof(sigregs));
+ memset(&fr, 0, sizeof(fr));
+ fr.sf_scp = &frp->sf_sc;
#if defined(__i386__)
- sc.trap_style = rp->p_seg.p_kern_trap_style;
+ fr.sf_sc.sc_gs = rp->p_reg.gs;
+ fr.sf_sc.sc_fs = rp->p_reg.fs;
+ fr.sf_sc.sc_es = rp->p_reg.es;
+ fr.sf_sc.sc_ds = rp->p_reg.ds;
+ fr.sf_sc.sc_edi = rp->p_reg.di;
+ fr.sf_sc.sc_esi = rp->p_reg.si;
+ fr.sf_sc.sc_ebp = rp->p_reg.fp;
+ fr.sf_sc.sc_ebx = rp->p_reg.bx;
+ fr.sf_sc.sc_edx = rp->p_reg.dx;
+ fr.sf_sc.sc_ecx = rp->p_reg.cx;
+ fr.sf_sc.sc_eax = rp->p_reg.retreg;
+ fr.sf_sc.sc_eip = rp->p_reg.pc;
+ fr.sf_sc.sc_cs = rp->p_reg.cs;
+ fr.sf_sc.sc_eflags = rp->p_reg.psw;
+ fr.sf_sc.sc_esp = rp->p_reg.sp;
+ fr.sf_sc.sc_ss = rp->p_reg.ss;
+ fr.sf_fp = rp->p_reg.fp;
+ fr.sf_signum = smsg.sm_signo;
+ rp->p_reg.fp = (reg_t) &frp->sf_fp;
+ fr.sf_scpcopy = fr.sf_scp;
+ fr.sf_ra_sigreturn = smsg.sm_sigreturn;
+ fr.sf_ra= rp->p_reg.pc;
+
+ fr.sf_sc.trap_style = rp->p_seg.p_kern_trap_style;
- if (sc.trap_style == KTS_NONE) {
+ if (fr.sf_sc.trap_style == KTS_NONE) {
printf("do_sigsend: sigsend an unsaved process\n");
return EINVAL;
}
if (proc_used_fpu(rp)) {
/* save the FPU context before saving it to the sig context */
save_fpu(rp);
- memcpy(&sc.sc_fpu_state, rp->p_seg.fpu_state, FPU_XFP_SIZE);
+ memcpy(&fr.sf_sc.sc_fpu_state, rp->p_seg.fpu_state, FPU_XFP_SIZE);
}
#endif
- /* Finish the sigcontext initialization. */
- sc.sc_mask = smsg.sm_mask;
- sc.sc_flags = rp->p_misc_flags & MF_FPU_INITIALIZED;
+#if defined(__arm__)
+ fr.sf_sc.sc_spsr = rp->p_reg.psr;
+ fr.sf_sc.sc_r0 = rp->p_reg.retreg;
+ fr.sf_sc.sc_r1 = rp->p_reg.r1;
+ fr.sf_sc.sc_r2 = rp->p_reg.r2;
+ fr.sf_sc.sc_r3 = rp->p_reg.r3;
+ fr.sf_sc.sc_r4 = rp->p_reg.r4;
+ fr.sf_sc.sc_r5 = rp->p_reg.r5;
+ fr.sf_sc.sc_r6 = rp->p_reg.r6;
+ fr.sf_sc.sc_r7 = rp->p_reg.r7;
+ fr.sf_sc.sc_r8 = rp->p_reg.r8;
+ fr.sf_sc.sc_r9 = rp->p_reg.r9;
+ fr.sf_sc.sc_r10 = rp->p_reg.r10;
+ fr.sf_sc.sc_r11 = rp->p_reg.fp;
+ fr.sf_sc.sc_r12 = rp->p_reg.r12;
+ fr.sf_sc.sc_usr_sp = rp->p_reg.sp;
+ fr.sf_sc.sc_usr_lr = rp->p_reg.lr;
+ fr.sf_sc.sc_svc_lr = 0; /* ? */
+ fr.sf_sc.sc_pc = rp->p_reg.pc; /* R15 */
+#endif
- /* Copy the sigcontext structure to the user's stack. */
- if ((r = data_copy_vmcheck(caller, KERNEL, (vir_bytes)&sc,
- m_ptr->m_sigcalls.endpt, (vir_bytes)scp,
- (vir_bytes)sizeof(struct sigcontext))) != OK)
- return r;
+ /* Finish the sigcontext initialization. */
+ fr.sf_sc.sc_mask = smsg.sm_mask;
+ fr.sf_sc.sc_flags = rp->p_misc_flags & MF_FPU_INITIALIZED;
+ fr.sf_sc.sc_magic = SC_MAGIC;
/* Initialize the sigframe structure. */
- frp = (struct sigframe *) scp - 1;
- fr.sf_scpcopy = scp;
- fr.sf_retadr2= (void (*)()) rp->p_reg.pc;
- fr.sf_fp = rp->p_reg.fp;
- rp->p_reg.fp = (reg_t) &frp->sf_fp;
- fr.sf_scp = scp;
-
- fpu_sigcontext(rp, &fr, &sc);
- fr.sf_signo = smsg.sm_signo;
- fr.sf_retadr = (void (*)()) smsg.sm_sigreturn;
+ fpu_sigcontext(rp, &fr, &fr.sf_sc);
#if defined(__arm__)
/* use the ARM link register to set the return address from the signal
* handler
*/
- rp->p_reg.lr = (reg_t) fr.sf_retadr;
+ rp->p_reg.lr = (reg_t) smsg.sm_sigreturn;
if(rp->p_reg.lr & 1) { printf("sigsend: LSB LR makes no sense.\n"); }
/* pass signal handler parameters in registers */
- rp->p_reg.retreg = (reg_t) fr.sf_signo;
- rp->p_reg.r1 = (reg_t) fr.sf_code;
+ rp->p_reg.retreg = (reg_t) smsg.sm_signo;
+ rp->p_reg.r1 = 0; /* sf_code */
rp->p_reg.r2 = (reg_t) fr.sf_scp;
rp->p_misc_flags |= MF_CONTEXT_SET;
#endif
/* Copy the sigframe structure to the user's stack. */
if ((r = data_copy_vmcheck(caller, KERNEL, (vir_bytes)&fr,
m_ptr->m_sigcalls.endpt, (vir_bytes)frp,
- (vir_bytes)sizeof(struct sigframe))) != OK)
+ (vir_bytes)sizeof(struct sigframe_sigcontext))) != OK)
return r;
/* Reset user registers to execute the signal handler. */
IMPORT(_sigreturn)
ENTRY(__sigreturn)
- add sp, sp, #24 /* make sp point to sigframe.sf_scpcopy */
- pop {r0} /* load it into r0 as parameter */
+ pop {r0} /* load sigframe.sf_scp into r0 as parameter */
b _C_LABEL(_sigreturn) /* _sigreturn(struct sigcontext *sf_scpcopy) */
#include <sys/cdefs.h>
-#include <sys/signal.h>
+#include <sys/types.h>
#include <sys/sigtypes.h>
+#include <sys/signal.h>
#include <lib.h>
#include <string.h>
#include "namespace.h"
#include <lib.h>
#include <string.h>
+#include <assert.h>
#include <signal.h>
#include <string.h>
#include <sys/signal.h>
#include <lib.h>
#include "namespace.h"
+#include <sys/types.h>
#include <sys/statvfs.h>
#include <string.h>
#include <minix/ipc.h>
#include <minix/com.h>
#include <minix/syslib.h>
+#include <machine/stackframe.h>
#include "vassert.h"
VAssert_StateWrapper vassert_state ALIGNED(VASSERT_PAGE_SIZE);
/*
* Signal frame. Pushed onto user stack before calling sigcode.
*/
-#ifdef COMPAT_16
+#if defined(COMPAT_16) || defined(__minix)
struct sigframe_sigcontext {
+#ifdef __minix
+ struct sigcontext *sf_scp; /* Let sigreturn find sigcontext */
+#endif
struct sigcontext sf_sc;
};
#endif
+
/* the pointers are use in the trampoline code to locate the ucontext */
struct sigframe_siginfo {
siginfo_t sf_si; /* actual saved siginfo */
-#ifndef _ARM_SIGNAL_H_
-#define _ARM_SIGNAL_H_
+/* $NetBSD: signal.h,v 1.12 2011/06/30 20:09:20 wiz Exp $ */
+
+/*
+ * Copyright (c) 1994-1996 Mark Brinicombe.
+ * Copyright (c) 1994 Brini.
+ * All rights reserved.
+ *
+ * This code is derived from software written for Brini by Mark Brinicombe
+ *
+ * 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.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by Brini.
+ * 4. The name of the company nor the name of the author may be used to
+ * endorse or promote products derived from this software without specific
+ * prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY BRINI ``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 BRINI 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.
+ *
+ * RiscBSD kernel project
+ *
+ * signal.h
+ *
+ * Architecture dependent signal types and structures
+ *
+ * Created : 30/09/94
+ */
+
+#ifndef _ARM32_SIGNAL_H_
+#define _ARM32_SIGNAL_H_
#include <sys/featuretest.h>
+#ifndef _LOCORE
typedef int sig_atomic_t;
+#endif
-/* The following structure should match the stackframe_s structure used
- * by the kernel's context switching code. Floating point registers should
- * be added in a different struct.
+#if defined(_NETBSD_SOURCE)
+
+#ifndef _LOCORE
+/*
+ * Information pushed on stack when a signal is delivered.
+ * This is used by the kernel to restore state following
+ * execution of the signal handler. It is also made available
+ * to the handler to allow it to restore state properly if
+ * a non-standard exit is performed.
*/
-#include <machine/stackframe.h>
-
-typedef struct stackframe_s sigregs;
-struct sigframe { /* stack frame created for signalled process */
- void (*sf_retadr)(void);
- int sf_signo;
- int sf_code;
- struct sigcontext *sf_scp;
- int sf_fp;
- void (*sf_retadr2)(void);
- struct sigcontext *sf_scpcopy;
+#if defined(__LIBC12_SOURCE__) || defined(_KERNEL)
+struct sigcontext13 {
+ int sc_onstack; /* sigstack state to restore */
+ int sc_mask; /* signal mask to restore (old style) */
+
+ unsigned int sc_spsr;
+ unsigned int sc_r0;
+ unsigned int sc_r1;
+ unsigned int sc_r2;
+ unsigned int sc_r3;
+ unsigned int sc_r4;
+ unsigned int sc_r5;
+ unsigned int sc_r6;
+ unsigned int sc_r7;
+ unsigned int sc_r8;
+ unsigned int sc_r9;
+ unsigned int sc_r10;
+ unsigned int sc_r11;
+ unsigned int sc_r12;
+ unsigned int sc_usr_sp;
+ unsigned int sc_usr_lr;
+ unsigned int sc_svc_lr;
+ unsigned int sc_pc;
};
+#endif /* __LIBC12_SOURCE__ || _KERNEL */
struct sigcontext {
- int trap_style; /* how should context be restored? KTS_* */
- int sc_flags; /* sigstack state to restore (including
- * MF_FPU_INITIALIZED)
- */
- sigset_t sc_mask; /* signal mask to restore */
- sigregs sc_regs; /* register set to restore */
+ int sc_onstack; /* sigstack state to restore */
+ int __sc_mask13; /* signal mask to restore (old style) */
+
+ unsigned int sc_spsr;
+ unsigned int sc_r0;
+ unsigned int sc_r1;
+ unsigned int sc_r2;
+ unsigned int sc_r3;
+ unsigned int sc_r4;
+ unsigned int sc_r5;
+ unsigned int sc_r6;
+ unsigned int sc_r7;
+ unsigned int sc_r8;
+ unsigned int sc_r9;
+ unsigned int sc_r10;
+ unsigned int sc_r11;
+ unsigned int sc_r12;
+ unsigned int sc_usr_sp;
+ unsigned int sc_usr_lr;
+ unsigned int sc_svc_lr;
+ unsigned int sc_pc;
+
+ sigset_t sc_mask; /* signal mask to restore (new style) */
+#ifdef __minix
+#define SC_MAGIC 0xc0ffee2
+ int sc_magic;
+ int sc_flags;
+ int trap_style;
+#endif
};
-#define sc_retreg sc_regs.retreg
-#define sc_r1 sc_regs.r1
-#define sc_r2 sc_regs.r2
-#define sc_r3 sc_regs.r3
-#define sc_r4 sc_regs.r4
-#define sc_r5 sc_regs.r5
-#define sc_r6 sc_regs.r6
-#define sc_r7 sc_regs.r7
-#define sc_r8 sc_regs.r8
-#define sc_r9 sc_regs.r9
-#define sc_r10 sc_regs.r10
-#define sc_fp sc_regs.fp
-#define sc_r12 sc_regs.r12
-#define sc_sp sc_regs.sp
-#define sc_lr sc_regs.lr
-#define sc_pc sc_regs.pc
-#define sc_psr sc_regs.psr
-
-#if defined(__minix) && defined(_NETBSD_SOURCE)
+#endif /* !_LOCORE */
+
+/* Signals codes */
+
+/*
+ * SIGFPE codes
+ *
+ * see ieeefp.h for definition of FP exception codes
+ */
+
+#define SIG_CODE_FPE_CODE_MASK 0x00000f00 /* Mask for exception code */
+#define SIG_CODE_FPE_CODE_SHIFT 8 /* Shift for exception code */
+#define SIG_CODE_FPE_TYPE_MASK 0x000000ff /* Mask for specific code */
+
+/*
+ * SIGILL codes
+ *
+ * the signal code is the instruction that raised the signal
+ */
+
+/*
+ * SIGBUS and SIGSEGV codes
+ *
+ * The signal code is combination of the fault address and the fault code.
+ *
+ * The fault code is the coproc #15 fault status code
+ *
+ * The exception to this is a SIGBUS or SIGSEGV from a prefetch abort.
+ * In this case the fault status code is not valid so the TYPE_MASK
+ * should be treated as undefined (in practice it is the bottom 4 bits
+ * of the fault address).
+ */
+
+#define SIG_CODE_BUS_ADDR_MASK 0xfffffff0
+#define SIG_CODE_BUS_TYPE_MASK 0x0000000f
+#define SIG_CODE_SEGV_ADDR_MASK SIG_CODE_BUS_ADDR_MASK
+#define SIG_CODE_SEGV_TYPE_MASK SIG_CODE_BUS_TYPE_MASK
+
+#endif /* _NETBSD_SOURCE */
+
+#if defined(__minix)
__BEGIN_DECLS
int sigreturn(struct sigcontext *_scp);
__END_DECLS
-#endif /* defined(__minix) && defined(_NETBSD_SOURCE) */
+#endif /* defined(__minix) */
#endif /* !_ARM_SIGNAL_H_ */
+
+/* End of signal.h */
cdefs.h cpu.h \
disklabel.h \
elf_machdep.h endian.h endian_machdep.h \
- float.h \
+ float.h frame.h \
ieee.h ieeefp.h \
int_const.h int_fmtio.h int_limits.h int_mwgwtypes.h int_types.h \
\
--- /dev/null
+/* $NetBSD: frame.h,v 1.2 2001/11/25 15:56:04 thorpej Exp $ */
+
+#include <arm/arm32/frame.h>
limits.h \
math.h mcontext.h mutex.h multiboot.h \
npx.h \
- param.h pio.h profile.h ptrace.h \
+ param.h pio.h profile.h ptrace.h trap.h \
\
rwlock.h \
setjmp.h signal.h \
int sf_eip;
};
-#ifdef _KERNEL
+#if defined(_KERNEL) || defined(__minix)
/*
* Old-style signal frame
*/
struct sigframe_sigcontext {
+#ifdef __minix
+ /* ret addr + stackframe for handler */
+ int sf_ra_sigreturn; /* first return to sigreturn */
+#else
int sf_ra; /* return address for handler */
+#endif
int sf_signum; /* "signum" argument for handler */
int sf_code; /* "code" argument for handler */
struct sigcontext *sf_scp; /* "scp" argument for handler */
+#ifdef __minix
+ /* ret addr + stackframe for sigreturn */
+ uint32_t sf_fp; /* saved FP */
+ int sf_ra; /* actual return address for handler */
+ struct sigcontext *sf_scpcopy; /* minix scp copy */
+#endif
struct sigcontext sf_sc; /* actual saved context */
};
#endif
+/* $NetBSD: signal.h,v 1.29 2008/11/19 18:35:59 ad Exp $ */
+
+/*
+ * Copyright (c) 1982, 1986, 1989, 1991 Regents of the University of California.
+ * 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.
+ * 3. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS 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.
+ *
+ * @(#)signal.h 7.16 (Berkeley) 3/17/91
+ */
+
#ifndef _I386_SIGNAL_H_
#define _I386_SIGNAL_H_
#include <sys/featuretest.h>
+#ifdef __minix
+#include <machine/fpu.h>
+#endif
+
typedef int sig_atomic_t;
-/* The following structure should match the stackframe_s structure used
- * by the kernel's context switching code. Floating point registers should
- * be added in a different struct.
+#if defined(_NETBSD_SOURCE)
+/*
+ * Get the "code" values
*/
+#include <machine/trap.h>
-#include <machine/stackframe.h>
-#include <machine/fpu.h>
+#if defined(_KERNEL) || defined(__minix)
+/*
+ * Information pushed on stack when a signal is delivered.
+ * This is used by the kernel to restore state following
+ * execution of the signal handler. It is also made available
+ * to the handler to allow it to restore state properly if
+ * a non-standard exit is performed.
+ */
+struct sigcontext13 {
+ int sc_gs;
+ int sc_fs;
+ int sc_es;
+ int sc_ds;
+ int sc_edi;
+ int sc_esi;
+ int sc_ebp;
+ int sc_ebx;
+ int sc_edx;
+ int sc_ecx;
+ int sc_eax;
+ /* XXX */
+ int sc_eip;
+ int sc_cs;
+ int sc_eflags;
+ int sc_esp;
+ int sc_ss;
+
+ int sc_onstack; /* sigstack state to restore */
+ int sc_mask; /* signal mask to restore (old style) */
-typedef struct stackframe_s sigregs;
-struct sigframe { /* stack frame created for signalled process */
- void (*sf_retadr)(void);
- int sf_signo;
- int sf_code;
- struct sigcontext *sf_scp;
- int sf_fp;
- void (*sf_retadr2)(void);
- struct sigcontext *sf_scpcopy;
+ int sc_trapno; /* XXX should be above */
+ int sc_err;
};
struct sigcontext {
- int trap_style; /* how should context be restored? KTS_* */
- int sc_flags; /* sigstack state to restore (including
- * MF_FPU_INITIALIZED)
- */
- sigset_t sc_mask; /* signal mask to restore */
- sigregs sc_regs; /* register set to restore */
- union fpu_state_u sc_fpu_state;
+ int sc_gs;
+ int sc_fs;
+ int sc_es;
+ int sc_ds;
+ int sc_edi;
+ int sc_esi;
+ int sc_ebp;
+ int sc_ebx;
+ int sc_edx;
+ int sc_ecx;
+ int sc_eax;
+ /* XXX */
+ int sc_eip;
+ int sc_cs;
+ int sc_eflags;
+ int sc_esp;
+ int sc_ss;
+
+ int sc_onstack; /* sigstack state to restore */
+ int __sc_mask13; /* signal mask to restore (old style) */
+
+ int sc_trapno; /* XXX should be above */
+ int sc_err;
+
+ sigset_t sc_mask; /* signal mask to restore (new style) */
+#ifdef __minix
+ union fpu_state_u sc_fpu_state;
+ int trap_style; /* KTS_* method of entering kernel */
+ int sc_flags; /* MF_FPU_INITIALIZED if fpu state valid */
+#define SC_MAGIC 0xc0ffee1
+ int sc_magic;
+#endif
};
+#endif /* _KERNEL */
-#define sc_gs sc_regs.gs
-#define sc_fs sc_regs.fs
-#define sc_es sc_regs.es
-#define sc_ds sc_regs.ds
-#define sc_di sc_regs.di
-#define sc_si sc_regs.si
-#define sc_fp sc_regs.bp
-#define sc_st sc_regs.st /* stack top -- used in kernel */
-#define sc_bx sc_regs.bx
-#define sc_dx sc_regs.dx
-#define sc_cx sc_regs.cx
-#define sc_retreg sc_regs.retreg
-#define sc_retadr sc_regs.retadr /* return address to caller of
- save -- used in kernel */
-#define sc_pc sc_regs.pc
-#define sc_cs sc_regs.cs
-#define sc_psw sc_regs.psw
-#define sc_sp sc_regs.sp
-#define sc_ss sc_regs.ss
-
-#if defined(__minix) && defined(_NETBSD_SOURCE)
+#if defined(__minix)
__BEGIN_DECLS
-int sigreturn(struct sigcontext *_scp);
+int sigreturn(struct sigcontext *_scp);
__END_DECLS
-#endif /* defined(__minix) && defined(_NETBSD_SOURCE) */
+#endif /* defined(__minix) */
+#endif /* _NETBSD_SOURCE */
#endif /* !_I386_SIGNAL_H_ */
--- /dev/null
+/* $NetBSD: trap.h,v 1.7 2003/02/26 21:29:03 fvdl Exp $ */
+
+#include <x86/trap.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
+#include <machine/frame.h>
int max_error = 4;
#include "common.h"
static void signal_handler(int signum)
{
- struct sigframe *sigframe;
+ struct sigframe_sigcontext *sigframe;
/* report signal */
- sigframe = (struct sigframe *) ((char *) &signum -
- (char *) &((struct sigframe *) NULL)->sf_signo);
- printf("Signal %d at 0x%x\n", signum, sigframe->sf_scp->sc_regs.pc);
+ sigframe = (struct sigframe_sigcontext *) ((char *) &signum -
+ (char *) &((struct sigframe_sigcontext *) NULL)->sf_signum);
+ printf("Signal %d at 0x%x\n", signum, sigframe->sf_scp->sc_eip);
/* count as error */
e(0);