linux-user/m68k/signal.c - third_party/qemu - Git at Google

 /*
  *  Emulation of Linux signals
  *
  *  Copyright (c) 2003 Fabrice Bellard
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 #include "qemu/osdep.h"
 #include "qemu.h"
 #include "user-internals.h"
 #include "signal-common.h"
 #include "linux-user/trace.h"

 struct target_sigcontext {
     abi_ulong  sc_mask;
     abi_ulong  sc_usp;
     abi_ulong  sc_d0;
     abi_ulong  sc_d1;
     abi_ulong  sc_a0;
     abi_ulong  sc_a1;
     unsigned short sc_sr;
     abi_ulong  sc_pc;
 };

 struct target_sigframe
 {
     abi_ulong pretcode;
     int sig;
     int code;
     abi_ulong psc;
     abi_ulong extramask[TARGET_NSIG_WORDS-1];
     struct target_sigcontext sc;
 };

 typedef int target_greg_t;
 #define TARGET_NGREG 18
 typedef target_greg_t target_gregset_t[TARGET_NGREG];

 typedef struct target_fpregset {
     int f_fpcntl[3];
     int f_fpregs[8*3];
 } target_fpregset_t;

 struct target_mcontext {
     int version;
     target_gregset_t gregs;
     target_fpregset_t fpregs;
 };

 #define TARGET_MCONTEXT_VERSION 2

 struct target_ucontext {
     abi_ulong tuc_flags;
     abi_ulong tuc_link;
     target_stack_t tuc_stack;
     struct target_mcontext tuc_mcontext;
     abi_long tuc_filler[80];
     target_sigset_t tuc_sigmask;
 };

 struct target_rt_sigframe
 {
     abi_ulong pretcode;
     int sig;
     abi_ulong pinfo;
     abi_ulong puc;
     struct target_siginfo info;
     struct target_ucontext uc;
 };

 static void setup_sigcontext(struct target_sigcontext *sc, CPUM68KState *env,
                              abi_ulong mask)
 {
     uint32_t sr = (env->sr & 0xff00) | cpu_m68k_get_ccr(env);
     __put_user(mask, &sc->sc_mask);
     __put_user(env->aregs[7], &sc->sc_usp);
     __put_user(env->dregs[0], &sc->sc_d0);
     __put_user(env->dregs[1], &sc->sc_d1);
     __put_user(env->aregs[0], &sc->sc_a0);
     __put_user(env->aregs[1], &sc->sc_a1);
     __put_user(sr, &sc->sc_sr);
     __put_user(env->pc, &sc->sc_pc);
 }

 static void
 restore_sigcontext(CPUM68KState *env, struct target_sigcontext *sc)
 {
     int temp;

     __get_user(env->aregs[7], &sc->sc_usp);
     __get_user(env->dregs[0], &sc->sc_d0);
     __get_user(env->dregs[1], &sc->sc_d1);
     __get_user(env->aregs[0], &sc->sc_a0);
     __get_user(env->aregs[1], &sc->sc_a1);
     __get_user(env->pc, &sc->sc_pc);
     __get_user(temp, &sc->sc_sr);
     cpu_m68k_set_ccr(env, temp);
 }

 /*
  * Determine which stack to use..
  */
 static inline abi_ulong
 get_sigframe(struct target_sigaction *ka, CPUM68KState *regs,
              size_t frame_size)
 {
     abi_ulong sp;

     sp = target_sigsp(get_sp_from_cpustate(regs), ka);


     return ((sp - frame_size) & -8UL);
 }

 void setup_frame(int sig, struct target_sigaction *ka,
                  target_sigset_t *set, CPUM68KState *env)
 {
     struct target_sigframe *frame;
     abi_ulong frame_addr;
     abi_ulong sc_addr;
     int i;

     frame_addr = get_sigframe(ka, env, sizeof *frame);
     trace_user_setup_frame(env, frame_addr);
     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
         goto give_sigsegv;
     }

     __put_user(sig, &frame->sig);

     sc_addr = frame_addr + offsetof(struct target_sigframe, sc);
     __put_user(sc_addr, &frame->psc);

     setup_sigcontext(&frame->sc, env, set->sig[0]);

     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
         __put_user(set->sig[i], &frame->extramask[i - 1]);
     }

     /* Set up to return from userspace.  */
     __put_user(default_sigreturn, &frame->pretcode);

     env->aregs[7] = frame_addr;
     env->pc = ka->_sa_handler;

     unlock_user_struct(frame, frame_addr, 1);
     return;

 give_sigsegv:
     force_sigsegv(sig);
 }

 static inline void target_rt_save_fpu_state(struct target_ucontext *uc,
                                            CPUM68KState *env)
 {
     int i;
     target_fpregset_t *fpregs = &uc->tuc_mcontext.fpregs;

     __put_user(env->fpcr, &fpregs->f_fpcntl[0]);
     __put_user(env->fpsr, &fpregs->f_fpcntl[1]);
     /* fpiar is not emulated */

     for (i = 0; i < 8; i++) {
         uint32_t high = env->fregs[i].d.high << 16;
         __put_user(high, &fpregs->f_fpregs[i * 3]);
         __put_user(env->fregs[i].d.low,
                    (uint64_t *)&fpregs->f_fpregs[i * 3 + 1]);
     }
 }

 static inline int target_rt_setup_ucontext(struct target_ucontext *uc,
                                            CPUM68KState *env)
 {
     target_greg_t *gregs = uc->tuc_mcontext.gregs;
     uint32_t sr = (env->sr & 0xff00) | cpu_m68k_get_ccr(env);

     __put_user(TARGET_MCONTEXT_VERSION, &uc->tuc_mcontext.version);
     __put_user(env->dregs[0], &gregs[0]);
     __put_user(env->dregs[1], &gregs[1]);
     __put_user(env->dregs[2], &gregs[2]);
     __put_user(env->dregs[3], &gregs[3]);
     __put_user(env->dregs[4], &gregs[4]);
     __put_user(env->dregs[5], &gregs[5]);
     __put_user(env->dregs[6], &gregs[6]);
     __put_user(env->dregs[7], &gregs[7]);
     __put_user(env->aregs[0], &gregs[8]);
     __put_user(env->aregs[1], &gregs[9]);
     __put_user(env->aregs[2], &gregs[10]);
     __put_user(env->aregs[3], &gregs[11]);
     __put_user(env->aregs[4], &gregs[12]);
     __put_user(env->aregs[5], &gregs[13]);
     __put_user(env->aregs[6], &gregs[14]);
     __put_user(env->aregs[7], &gregs[15]);
     __put_user(env->pc, &gregs[16]);
     __put_user(sr, &gregs[17]);

     target_rt_save_fpu_state(uc, env);

     return 0;
 }

 static inline void target_rt_restore_fpu_state(CPUM68KState *env,
                                                struct target_ucontext *uc)
 {
     int i;
     target_fpregset_t *fpregs = &uc->tuc_mcontext.fpregs;
     uint32_t fpcr;

     __get_user(fpcr, &fpregs->f_fpcntl[0]);
     cpu_m68k_set_fpcr(env, fpcr);
     __get_user(env->fpsr, &fpregs->f_fpcntl[1]);
     /* fpiar is not emulated */

     for (i = 0; i < 8; i++) {
         uint32_t high;
         __get_user(high, &fpregs->f_fpregs[i * 3]);
         env->fregs[i].d.high = high >> 16;
         __get_user(env->fregs[i].d.low,
                    (uint64_t *)&fpregs->f_fpregs[i * 3 + 1]);
     }
 }

 static inline int target_rt_restore_ucontext(CPUM68KState *env,
                                              struct target_ucontext *uc)
 {
     int temp;
     target_greg_t *gregs = uc->tuc_mcontext.gregs;

     __get_user(temp, &uc->tuc_mcontext.version);
     if (temp != TARGET_MCONTEXT_VERSION)
         goto badframe;

     /* restore passed registers */
     __get_user(env->dregs[0], &gregs[0]);
     __get_user(env->dregs[1], &gregs[1]);
     __get_user(env->dregs[2], &gregs[2]);
     __get_user(env->dregs[3], &gregs[3]);
     __get_user(env->dregs[4], &gregs[4]);
     __get_user(env->dregs[5], &gregs[5]);
     __get_user(env->dregs[6], &gregs[6]);
     __get_user(env->dregs[7], &gregs[7]);
     __get_user(env->aregs[0], &gregs[8]);
     __get_user(env->aregs[1], &gregs[9]);
     __get_user(env->aregs[2], &gregs[10]);
     __get_user(env->aregs[3], &gregs[11]);
     __get_user(env->aregs[4], &gregs[12]);
     __get_user(env->aregs[5], &gregs[13]);
     __get_user(env->aregs[6], &gregs[14]);
     __get_user(env->aregs[7], &gregs[15]);
     __get_user(env->pc, &gregs[16]);
     __get_user(temp, &gregs[17]);
     cpu_m68k_set_ccr(env, temp);

     target_rt_restore_fpu_state(env, uc);

     return 0;

 badframe:
     return 1;
 }

 void setup_rt_frame(int sig, struct target_sigaction *ka,
                     target_siginfo_t *info,
                     target_sigset_t *set, CPUM68KState *env)
 {
     struct target_rt_sigframe *frame;
     abi_ulong frame_addr;
     abi_ulong info_addr;
     abi_ulong uc_addr;
     int err = 0;
     int i;

     frame_addr = get_sigframe(ka, env, sizeof *frame);
     trace_user_setup_rt_frame(env, frame_addr);
     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
         goto give_sigsegv;
     }

     __put_user(sig, &frame->sig);

     info_addr = frame_addr + offsetof(struct target_rt_sigframe, info);
     __put_user(info_addr, &frame->pinfo);

     uc_addr = frame_addr + offsetof(struct target_rt_sigframe, uc);
     __put_user(uc_addr, &frame->puc);

     tswap_siginfo(&frame->info, info);

     /* Create the ucontext */

     __put_user(0, &frame->uc.tuc_flags);
     __put_user(0, &frame->uc.tuc_link);
     target_save_altstack(&frame->uc.tuc_stack, env);
     err |= target_rt_setup_ucontext(&frame->uc, env);

     if (err)
         goto give_sigsegv;

     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
         __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
     }

     /* Set up to return from userspace.  */
     __put_user(default_rt_sigreturn, &frame->pretcode);

     env->aregs[7] = frame_addr;
     env->pc = ka->_sa_handler;

     unlock_user_struct(frame, frame_addr, 1);
     return;

 give_sigsegv:
     unlock_user_struct(frame, frame_addr, 1);
     force_sigsegv(sig);
 }

 long do_sigreturn(CPUM68KState *env)
 {
     struct target_sigframe *frame;
     abi_ulong frame_addr = env->aregs[7] - 4;
     target_sigset_t target_set;
     sigset_t set;
     int i;

     trace_user_do_sigreturn(env, frame_addr);
     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
         goto badframe;

     /* set blocked signals */

     __get_user(target_set.sig[0], &frame->sc.sc_mask);

     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
         __get_user(target_set.sig[i], &frame->extramask[i - 1]);
     }

     target_to_host_sigset_internal(&set, &target_set);
     set_sigmask(&set);

     /* restore registers */

     restore_sigcontext(env, &frame->sc);

     unlock_user_struct(frame, frame_addr, 0);
     return -QEMU_ESIGRETURN;

 badframe:
     force_sig(TARGET_SIGSEGV);
     return -QEMU_ESIGRETURN;
 }

 long do_rt_sigreturn(CPUM68KState *env)
 {
     struct target_rt_sigframe *frame;
     abi_ulong frame_addr = env->aregs[7] - 4;
     sigset_t set;

     trace_user_do_rt_sigreturn(env, frame_addr);
     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
         goto badframe;

     target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
     set_sigmask(&set);

     /* restore registers */

     if (target_rt_restore_ucontext(env, &frame->uc))
         goto badframe;

     target_restore_altstack(&frame->uc.tuc_stack, env);

     unlock_user_struct(frame, frame_addr, 0);
     return -QEMU_ESIGRETURN;

 badframe:
     unlock_user_struct(frame, frame_addr, 0);
     force_sig(TARGET_SIGSEGV);
     return -QEMU_ESIGRETURN;
 }

 void setup_sigtramp(abi_ulong sigtramp_page)
 {
     void *tramp = lock_user(VERIFY_WRITE, sigtramp_page, 4 + 6, 0);
     assert(tramp != NULL);

     default_sigreturn = sigtramp_page;

     /* moveq #,d0; trap #0 */
     __put_user(0x70004e40 + (TARGET_NR_sigreturn << 16), (uint32_t *)tramp);

     default_rt_sigreturn = sigtramp_page + 4;

     /* moveq #,d0; notb d0; trap #0 */
     __put_user(0x70004600 + ((TARGET_NR_rt_sigreturn ^ 0xff) << 16),
                (uint32_t *)(tramp + 4));
     __put_user(0x4e40, (uint16_t *)(tramp + 8));

     unlock_user(tramp, sigtramp_page, 4 + 6);
 }
	/*
	* Emulation of Linux signals
	*
	* Copyright (c) 2003 Fabrice Bellard
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, see <http://www.gnu.org/licenses/>.
	*/
	#include "qemu/osdep.h"
	#include "qemu.h"
	#include "user-internals.h"
	#include "signal-common.h"
	#include "linux-user/trace.h"

	struct target_sigcontext {
	abi_ulong sc_mask;
	abi_ulong sc_usp;
	abi_ulong sc_d0;
	abi_ulong sc_d1;
	abi_ulong sc_a0;
	abi_ulong sc_a1;
	unsigned short sc_sr;
	abi_ulong sc_pc;
	};

	struct target_sigframe
	{
	abi_ulong pretcode;
	int sig;
	int code;
	abi_ulong psc;
	abi_ulong extramask[TARGET_NSIG_WORDS-1];
	struct target_sigcontext sc;
	};

	typedef int target_greg_t;
	#define TARGET_NGREG 18
	typedef target_greg_t target_gregset_t[TARGET_NGREG];

	typedef struct target_fpregset {
	int f_fpcntl[3];
	int f_fpregs[8*3];
	} target_fpregset_t;

	struct target_mcontext {
	int version;
	target_gregset_t gregs;
	target_fpregset_t fpregs;
	};

	#define TARGET_MCONTEXT_VERSION 2

	struct target_ucontext {
	abi_ulong tuc_flags;
	abi_ulong tuc_link;
	target_stack_t tuc_stack;
	struct target_mcontext tuc_mcontext;
	abi_long tuc_filler[80];
	target_sigset_t tuc_sigmask;
	};

	struct target_rt_sigframe
	{
	abi_ulong pretcode;
	int sig;
	abi_ulong pinfo;
	abi_ulong puc;
	struct target_siginfo info;
	struct target_ucontext uc;
	};

	static void setup_sigcontext(struct target_sigcontext sc, CPUM68KState env,
	abi_ulong mask)
	{
	uint32_t sr = (env->sr & 0xff00) \| cpu_m68k_get_ccr(env);
	__put_user(mask, &sc->sc_mask);
	__put_user(env->aregs[7], &sc->sc_usp);
	__put_user(env->dregs[0], &sc->sc_d0);
	__put_user(env->dregs[1], &sc->sc_d1);
	__put_user(env->aregs[0], &sc->sc_a0);
	__put_user(env->aregs[1], &sc->sc_a1);
	__put_user(sr, &sc->sc_sr);
	__put_user(env->pc, &sc->sc_pc);
	}

	static void
	restore_sigcontext(CPUM68KState env, struct target_sigcontext sc)
	{
	int temp;

	__get_user(env->aregs[7], &sc->sc_usp);
	__get_user(env->dregs[0], &sc->sc_d0);
	__get_user(env->dregs[1], &sc->sc_d1);
	__get_user(env->aregs[0], &sc->sc_a0);
	__get_user(env->aregs[1], &sc->sc_a1);
	__get_user(env->pc, &sc->sc_pc);
	__get_user(temp, &sc->sc_sr);
	cpu_m68k_set_ccr(env, temp);
	}

	/*
	* Determine which stack to use..
	*/
	static inline abi_ulong
	get_sigframe(struct target_sigaction ka, CPUM68KState regs,
	size_t frame_size)
	{
	abi_ulong sp;

	sp = target_sigsp(get_sp_from_cpustate(regs), ka);


	return ((sp - frame_size) & -8UL);
	}

	void setup_frame(int sig, struct target_sigaction *ka,
	target_sigset_t set, CPUM68KState env)
	{
	struct target_sigframe *frame;
	abi_ulong frame_addr;
	abi_ulong sc_addr;
	int i;

	frame_addr = get_sigframe(ka, env, sizeof *frame);
	trace_user_setup_frame(env, frame_addr);
	if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
	goto give_sigsegv;
	}

	__put_user(sig, &frame->sig);

	sc_addr = frame_addr + offsetof(struct target_sigframe, sc);
	__put_user(sc_addr, &frame->psc);

	setup_sigcontext(&frame->sc, env, set->sig[0]);

	for(i = 1; i < TARGET_NSIG_WORDS; i++) {
	__put_user(set->sig[i], &frame->extramask[i - 1]);
	}

	/* Set up to return from userspace. */
	__put_user(default_sigreturn, &frame->pretcode);

	env->aregs[7] = frame_addr;
	env->pc = ka->_sa_handler;

	unlock_user_struct(frame, frame_addr, 1);
	return;

	give_sigsegv:
	force_sigsegv(sig);
	}

	static inline void target_rt_save_fpu_state(struct target_ucontext *uc,
	CPUM68KState *env)
	{
	int i;
	target_fpregset_t *fpregs = &uc->tuc_mcontext.fpregs;

	__put_user(env->fpcr, &fpregs->f_fpcntl[0]);
	__put_user(env->fpsr, &fpregs->f_fpcntl[1]);
	/* fpiar is not emulated */

	for (i = 0; i < 8; i++) {
	uint32_t high = env->fregs[i].d.high << 16;
	__put_user(high, &fpregs->f_fpregs[i * 3]);
	__put_user(env->fregs[i].d.low,
	(uint64_t )&fpregs->f_fpregs[i 3 + 1]);
	}
	}

	static inline int target_rt_setup_ucontext(struct target_ucontext *uc,
	CPUM68KState *env)
	{
	target_greg_t *gregs = uc->tuc_mcontext.gregs;
	uint32_t sr = (env->sr & 0xff00) \| cpu_m68k_get_ccr(env);

	__put_user(TARGET_MCONTEXT_VERSION, &uc->tuc_mcontext.version);
	__put_user(env->dregs[0], &gregs[0]);
	__put_user(env->dregs[1], &gregs[1]);
	__put_user(env->dregs[2], &gregs[2]);
	__put_user(env->dregs[3], &gregs[3]);
	__put_user(env->dregs[4], &gregs[4]);
	__put_user(env->dregs[5], &gregs[5]);
	__put_user(env->dregs[6], &gregs[6]);
	__put_user(env->dregs[7], &gregs[7]);
	__put_user(env->aregs[0], &gregs[8]);
	__put_user(env->aregs[1], &gregs[9]);
	__put_user(env->aregs[2], &gregs[10]);
	__put_user(env->aregs[3], &gregs[11]);
	__put_user(env->aregs[4], &gregs[12]);
	__put_user(env->aregs[5], &gregs[13]);
	__put_user(env->aregs[6], &gregs[14]);
	__put_user(env->aregs[7], &gregs[15]);
	__put_user(env->pc, &gregs[16]);
	__put_user(sr, &gregs[17]);

	target_rt_save_fpu_state(uc, env);

	return 0;
	}

	static inline void target_rt_restore_fpu_state(CPUM68KState *env,
	struct target_ucontext *uc)
	{
	int i;
	target_fpregset_t *fpregs = &uc->tuc_mcontext.fpregs;
	uint32_t fpcr;

	__get_user(fpcr, &fpregs->f_fpcntl[0]);
	cpu_m68k_set_fpcr(env, fpcr);
	__get_user(env->fpsr, &fpregs->f_fpcntl[1]);
	/* fpiar is not emulated */

	for (i = 0; i < 8; i++) {
	uint32_t high;
	__get_user(high, &fpregs->f_fpregs[i * 3]);
	env->fregs[i].d.high = high >> 16;
	__get_user(env->fregs[i].d.low,
	(uint64_t )&fpregs->f_fpregs[i 3 + 1]);
	}
	}

	static inline int target_rt_restore_ucontext(CPUM68KState *env,
	struct target_ucontext *uc)
	{
	int temp;
	target_greg_t *gregs = uc->tuc_mcontext.gregs;

	__get_user(temp, &uc->tuc_mcontext.version);
	if (temp != TARGET_MCONTEXT_VERSION)
	goto badframe;

	/* restore passed registers */
	__get_user(env->dregs[0], &gregs[0]);
	__get_user(env->dregs[1], &gregs[1]);
	__get_user(env->dregs[2], &gregs[2]);
	__get_user(env->dregs[3], &gregs[3]);
	__get_user(env->dregs[4], &gregs[4]);
	__get_user(env->dregs[5], &gregs[5]);
	__get_user(env->dregs[6], &gregs[6]);
	__get_user(env->dregs[7], &gregs[7]);
	__get_user(env->aregs[0], &gregs[8]);
	__get_user(env->aregs[1], &gregs[9]);
	__get_user(env->aregs[2], &gregs[10]);
	__get_user(env->aregs[3], &gregs[11]);
	__get_user(env->aregs[4], &gregs[12]);
	__get_user(env->aregs[5], &gregs[13]);
	__get_user(env->aregs[6], &gregs[14]);
	__get_user(env->aregs[7], &gregs[15]);
	__get_user(env->pc, &gregs[16]);
	__get_user(temp, &gregs[17]);
	cpu_m68k_set_ccr(env, temp);

	target_rt_restore_fpu_state(env, uc);

	return 0;

	badframe:
	return 1;
	}

	void setup_rt_frame(int sig, struct target_sigaction *ka,
	target_siginfo_t *info,
	target_sigset_t set, CPUM68KState env)
	{
	struct target_rt_sigframe *frame;
	abi_ulong frame_addr;
	abi_ulong info_addr;
	abi_ulong uc_addr;
	int err = 0;
	int i;

	frame_addr = get_sigframe(ka, env, sizeof *frame);
	trace_user_setup_rt_frame(env, frame_addr);
	if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
	goto give_sigsegv;
	}

	__put_user(sig, &frame->sig);

	info_addr = frame_addr + offsetof(struct target_rt_sigframe, info);
	__put_user(info_addr, &frame->pinfo);

	uc_addr = frame_addr + offsetof(struct target_rt_sigframe, uc);
	__put_user(uc_addr, &frame->puc);

	tswap_siginfo(&frame->info, info);

	/* Create the ucontext */

	__put_user(0, &frame->uc.tuc_flags);
	__put_user(0, &frame->uc.tuc_link);
	target_save_altstack(&frame->uc.tuc_stack, env);
	err \|= target_rt_setup_ucontext(&frame->uc, env);

	if (err)
	goto give_sigsegv;

	for(i = 0; i < TARGET_NSIG_WORDS; i++) {
	__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
	}

	/* Set up to return from userspace. */
	__put_user(default_rt_sigreturn, &frame->pretcode);

	env->aregs[7] = frame_addr;
	env->pc = ka->_sa_handler;

	unlock_user_struct(frame, frame_addr, 1);
	return;

	give_sigsegv:
	unlock_user_struct(frame, frame_addr, 1);
	force_sigsegv(sig);
	}

	long do_sigreturn(CPUM68KState *env)
	{
	struct target_sigframe *frame;
	abi_ulong frame_addr = env->aregs[7] - 4;
	target_sigset_t target_set;
	sigset_t set;
	int i;

	trace_user_do_sigreturn(env, frame_addr);
	if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
	goto badframe;

	/* set blocked signals */

	__get_user(target_set.sig[0], &frame->sc.sc_mask);

	for(i = 1; i < TARGET_NSIG_WORDS; i++) {
	__get_user(target_set.sig[i], &frame->extramask[i - 1]);
	}

	target_to_host_sigset_internal(&set, &target_set);
	set_sigmask(&set);

	/* restore registers */

	restore_sigcontext(env, &frame->sc);

	unlock_user_struct(frame, frame_addr, 0);
	return -QEMU_ESIGRETURN;

	badframe:
	force_sig(TARGET_SIGSEGV);
	return -QEMU_ESIGRETURN;
	}

	long do_rt_sigreturn(CPUM68KState *env)
	{
	struct target_rt_sigframe *frame;
	abi_ulong frame_addr = env->aregs[7] - 4;
	sigset_t set;

	trace_user_do_rt_sigreturn(env, frame_addr);
	if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
	goto badframe;

	target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
	set_sigmask(&set);

	/* restore registers */

	if (target_rt_restore_ucontext(env, &frame->uc))
	goto badframe;

	target_restore_altstack(&frame->uc.tuc_stack, env);

	unlock_user_struct(frame, frame_addr, 0);
	return -QEMU_ESIGRETURN;

	badframe:
	unlock_user_struct(frame, frame_addr, 0);
	force_sig(TARGET_SIGSEGV);
	return -QEMU_ESIGRETURN;
	}

	void setup_sigtramp(abi_ulong sigtramp_page)
	{
	void *tramp = lock_user(VERIFY_WRITE, sigtramp_page, 4 + 6, 0);
	assert(tramp != NULL);

	default_sigreturn = sigtramp_page;

	/* moveq #,d0; trap #0 */
	__put_user(0x70004e40 + (TARGET_NR_sigreturn << 16), (uint32_t *)tramp);

	default_rt_sigreturn = sigtramp_page + 4;

	/* moveq #,d0; notb d0; trap #0 */
	__put_user(0x70004600 + ((TARGET_NR_rt_sigreturn ^ 0xff) << 16),
	(uint32_t *)(tramp + 4));
	__put_user(0x4e40, (uint16_t *)(tramp + 8));

	unlock_user(tramp, sigtramp_page, 4 + 6);
	}