[qemu.git] / linux-user / nios2 / signal.c

/*
 *  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 "target_signal.h"
#include "signal-common.h"
#include "linux-user/trace.h"

#define MCONTEXT_VERSION 2

struct target_sigcontext {
    int version;
    unsigned long gregs[32];
};

struct target_ucontext {
    abi_ulong tuc_flags;
    abi_ulong tuc_link;
    target_stack_t tuc_stack;
    struct target_sigcontext tuc_mcontext;
    target_sigset_t tuc_sigmask;   /* mask last for extensibility */
};

struct target_rt_sigframe {
    struct target_siginfo info;
    struct target_ucontext uc;
};

static unsigned long sigsp(unsigned long sp, struct target_sigaction *ka)
{
    if (unlikely((ka->sa_flags & SA_ONSTACK)) && !sas_ss_flags(sp)) {
#ifdef CONFIG_STACK_GROWSUP
        return target_sigaltstack_used.ss_sp;
#else
        return target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
#endif
    }
    return sp;
}

static int rt_setup_ucontext(struct target_ucontext *uc, CPUNios2State *env)
{
    unsigned long *gregs = uc->tuc_mcontext.gregs;

    __put_user(MCONTEXT_VERSION, &uc->tuc_mcontext.version);
    __put_user(env->regs[1], &gregs[0]);
    __put_user(env->regs[2], &gregs[1]);
    __put_user(env->regs[3], &gregs[2]);
    __put_user(env->regs[4], &gregs[3]);
    __put_user(env->regs[5], &gregs[4]);
    __put_user(env->regs[6], &gregs[5]);
    __put_user(env->regs[7], &gregs[6]);
    __put_user(env->regs[8], &gregs[7]);
    __put_user(env->regs[9], &gregs[8]);
    __put_user(env->regs[10], &gregs[9]);
    __put_user(env->regs[11], &gregs[10]);
    __put_user(env->regs[12], &gregs[11]);
    __put_user(env->regs[13], &gregs[12]);
    __put_user(env->regs[14], &gregs[13]);
    __put_user(env->regs[15], &gregs[14]);
    __put_user(env->regs[16], &gregs[15]);
    __put_user(env->regs[17], &gregs[16]);
    __put_user(env->regs[18], &gregs[17]);
    __put_user(env->regs[19], &gregs[18]);
    __put_user(env->regs[20], &gregs[19]);
    __put_user(env->regs[21], &gregs[20]);
    __put_user(env->regs[22], &gregs[21]);
    __put_user(env->regs[23], &gregs[22]);
    __put_user(env->regs[R_RA], &gregs[23]);
    __put_user(env->regs[R_FP], &gregs[24]);
    __put_user(env->regs[R_GP], &gregs[25]);
    __put_user(env->regs[R_EA], &gregs[27]);
    __put_user(env->regs[R_SP], &gregs[28]);

    return 0;
}

static int rt_restore_ucontext(CPUNios2State *env, struct target_ucontext *uc,
                               int *pr2)
{
    int temp;
    abi_ulong off, frame_addr = env->regs[R_SP];
    unsigned long *gregs = uc->tuc_mcontext.gregs;
    int err;

    /* Always make any pending restarted system calls return -EINTR */
    /* current->restart_block.fn = do_no_restart_syscall; */

    __get_user(temp, &uc->tuc_mcontext.version);
    if (temp != MCONTEXT_VERSION) {
        return 1;
    }

    /* restore passed registers */
    __get_user(env->regs[1], &gregs[0]);
    __get_user(env->regs[2], &gregs[1]);
    __get_user(env->regs[3], &gregs[2]);
    __get_user(env->regs[4], &gregs[3]);
    __get_user(env->regs[5], &gregs[4]);
    __get_user(env->regs[6], &gregs[5]);
    __get_user(env->regs[7], &gregs[6]);
    __get_user(env->regs[8], &gregs[7]);
    __get_user(env->regs[9], &gregs[8]);
    __get_user(env->regs[10], &gregs[9]);
    __get_user(env->regs[11], &gregs[10]);
    __get_user(env->regs[12], &gregs[11]);
    __get_user(env->regs[13], &gregs[12]);
    __get_user(env->regs[14], &gregs[13]);
    __get_user(env->regs[15], &gregs[14]);
    __get_user(env->regs[16], &gregs[15]);
    __get_user(env->regs[17], &gregs[16]);
    __get_user(env->regs[18], &gregs[17]);
    __get_user(env->regs[19], &gregs[18]);
    __get_user(env->regs[20], &gregs[19]);
    __get_user(env->regs[21], &gregs[20]);
    __get_user(env->regs[22], &gregs[21]);
    __get_user(env->regs[23], &gregs[22]);
    /* gregs[23] is handled below */
    /* Verify, should this be settable */
    __get_user(env->regs[R_FP], &gregs[24]);
    /* Verify, should this be settable */
    __get_user(env->regs[R_GP], &gregs[25]);
    /* Not really necessary no user settable bits */
    __get_user(temp, &gregs[26]);
    __get_user(env->regs[R_EA], &gregs[27]);

    __get_user(env->regs[R_RA], &gregs[23]);
    __get_user(env->regs[R_SP], &gregs[28]);

    off = offsetof(struct target_rt_sigframe, uc.tuc_stack);
    err = do_sigaltstack(frame_addr + off, 0, get_sp_from_cpustate(env));
    if (err == -EFAULT) {
        return 1;
    }

    *pr2 = env->regs[2];
    return 0;
}

static void *get_sigframe(struct target_sigaction *ka, CPUNios2State *env,
                          size_t frame_size)
{
    unsigned long usp;

    /* Default to using normal stack.  */
    usp = env->regs[R_SP];

    /* This is the X/Open sanctioned signal stack switching.  */
    usp = sigsp(usp, ka);

    /* Verify, is it 32 or 64 bit aligned */
    return (void *)((usp - frame_size) & -8UL);
}

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

    frame = get_sigframe(ka, env, sizeof(*frame));

    if (ka->sa_flags & SA_SIGINFO) {
        tswap_siginfo(&frame->info, info);
    }

    /* Create the ucontext.  */
    __put_user(0, &frame->uc.tuc_flags);
    __put_user(0, &frame->uc.tuc_link);
    __put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp);
    __put_user(sas_ss_flags(env->regs[R_SP]), &frame->uc.tuc_stack.ss_flags);
    __put_user(target_sigaltstack_used.ss_size, &frame->uc.tuc_stack.ss_size);
    err |= rt_setup_ucontext(&frame->uc, env);
    for (i = 0; i < TARGET_NSIG_WORDS; i++) {
        __put_user((abi_ulong)set->sig[i],
            (abi_ulong *)&frame->uc.tuc_sigmask.sig[i]);
    }

    if (err) {
        goto give_sigsegv;
    }

    /* Set up to return from userspace; jump to fixed address sigreturn
       trampoline on kuser page.  */
    env->regs[R_RA] = (unsigned long) (0x1044);

    /* Set up registers for signal handler */
    env->regs[R_SP] = (unsigned long) frame;
    env->regs[4] = (unsigned long) sig;
    env->regs[5] = (unsigned long) &frame->info;
    env->regs[6] = (unsigned long) &frame->uc;
    env->regs[R_EA] = (unsigned long) ka->_sa_handler;
    return;

give_sigsegv:
    if (sig == TARGET_SIGSEGV) {
        ka->_sa_handler = TARGET_SIG_DFL;
    }
    force_sigsegv(sig);
    return;
}

long do_sigreturn(CPUNios2State *env)
{
    trace_user_do_sigreturn(env, 0);
    fprintf(stderr, "do_sigreturn: not implemented\n");
    return -TARGET_ENOSYS;
}

long do_rt_sigreturn(CPUNios2State *env)
{
    /* Verify, can we follow the stack back */
    abi_ulong frame_addr = env->regs[R_SP];
    struct target_rt_sigframe *frame;
    sigset_t set;
    int rval;

    if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
        goto badframe;
    }

    target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
    do_sigprocmask(SIG_SETMASK, &set, NULL);

    if (rt_restore_ucontext(env, &frame->uc, &rval)) {
        goto badframe;
    }

    unlock_user_struct(frame, frame_addr, 0);
    return rval;

badframe:
    unlock_user_struct(frame, frame_addr, 0);
    force_sig(TARGET_SIGSEGV);
    return 0;
}
Commit	Line	Data
befb7447 LV	1	/*
	2	* Emulation of Linux signals
	3	*
	4	* Copyright (c) 2003 Fabrice Bellard
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, see <http://www.gnu.org/licenses/>.
	18	*/
f7cd3e67 LV	19	#include "qemu/osdep.h"
	20	#include "qemu.h"
	21	#include "target_signal.h"
	22	#include "signal-common.h"
	23	#include "linux-user/trace.h"
	24
	25	#define MCONTEXT_VERSION 2
	26
	27	struct target_sigcontext {
	28	int version;
	29	unsigned long gregs[32];
	30	};
	31
	32	struct target_ucontext {
	33	abi_ulong tuc_flags;
	34	abi_ulong tuc_link;
	35	target_stack_t tuc_stack;
	36	struct target_sigcontext tuc_mcontext;
	37	target_sigset_t tuc_sigmask; /* mask last for extensibility */
	38	};
	39
	40	struct target_rt_sigframe {
	41	struct target_siginfo info;
	42	struct target_ucontext uc;
	43	};
	44
	45	static unsigned long sigsp(unsigned long sp, struct target_sigaction *ka)
	46	{
	47	if (unlikely((ka->sa_flags & SA_ONSTACK)) && !sas_ss_flags(sp)) {
	48	#ifdef CONFIG_STACK_GROWSUP
	49	return target_sigaltstack_used.ss_sp;
	50	#else
	51	return target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
	52	#endif
	53	}
	54	return sp;
	55	}
	56
	57	static int rt_setup_ucontext(struct target_ucontext uc, CPUNios2State env)
	58	{
	59	unsigned long *gregs = uc->tuc_mcontext.gregs;
	60
	61	__put_user(MCONTEXT_VERSION, &uc->tuc_mcontext.version);
	62	__put_user(env->regs[1], &gregs[0]);
	63	__put_user(env->regs[2], &gregs[1]);
	64	__put_user(env->regs[3], &gregs[2]);
	65	__put_user(env->regs[4], &gregs[3]);
	66	__put_user(env->regs[5], &gregs[4]);
	67	__put_user(env->regs[6], &gregs[5]);
	68	__put_user(env->regs[7], &gregs[6]);
	69	__put_user(env->regs[8], &gregs[7]);
	70	__put_user(env->regs[9], &gregs[8]);
	71	__put_user(env->regs[10], &gregs[9]);
	72	__put_user(env->regs[11], &gregs[10]);
	73	__put_user(env->regs[12], &gregs[11]);
	74	__put_user(env->regs[13], &gregs[12]);
	75	__put_user(env->regs[14], &gregs[13]);
	76	__put_user(env->regs[15], &gregs[14]);
	77	__put_user(env->regs[16], &gregs[15]);
	78	__put_user(env->regs[17], &gregs[16]);
	79	__put_user(env->regs[18], &gregs[17]);
	80	__put_user(env->regs[19], &gregs[18]);
	81	__put_user(env->regs[20], &gregs[19]);
	82	__put_user(env->regs[21], &gregs[20]);
83	__put_user(env->regs[22], &gregs[21]);
84	__put_user(env->regs[23], &gregs[22]);
85	__put_user(env->regs[R_RA], &gregs[23]);
86	__put_user(env->regs[R_FP], &gregs[24]);
87	__put_user(env->regs[R_GP], &gregs[25]);
88	__put_user(env->regs[R_EA], &gregs[27]);
89	__put_user(env->regs[R_SP], &gregs[28]);
90
91	return 0;
92	}
93
94	static int rt_restore_ucontext(CPUNios2State env, struct target_ucontext uc,
95	int *pr2)
96	{
97	int temp;
98	abi_ulong off, frame_addr = env->regs[R_SP];
99	unsigned long *gregs = uc->tuc_mcontext.gregs;
100	int err;
101
102	/* Always make any pending restarted system calls return -EINTR */
103	/* current->restart_block.fn = do_no_restart_syscall; */
104
105	__get_user(temp, &uc->tuc_mcontext.version);
106	if (temp != MCONTEXT_VERSION) {
107	return 1;
108	}
109
110	/* restore passed registers */
111	__get_user(env->regs[1], &gregs[0]);
112	__get_user(env->regs[2], &gregs[1]);
113	__get_user(env->regs[3], &gregs[2]);
114	__get_user(env->regs[4], &gregs[3]);
115	__get_user(env->regs[5], &gregs[4]);
116	__get_user(env->regs[6], &gregs[5]);
117	__get_user(env->regs[7], &gregs[6]);
118	__get_user(env->regs[8], &gregs[7]);
119	__get_user(env->regs[9], &gregs[8]);
120	__get_user(env->regs[10], &gregs[9]);
121	__get_user(env->regs[11], &gregs[10]);
122	__get_user(env->regs[12], &gregs[11]);
123	__get_user(env->regs[13], &gregs[12]);
124	__get_user(env->regs[14], &gregs[13]);
125	__get_user(env->regs[15], &gregs[14]);
126	__get_user(env->regs[16], &gregs[15]);
127	__get_user(env->regs[17], &gregs[16]);
128	__get_user(env->regs[18], &gregs[17]);
129	__get_user(env->regs[19], &gregs[18]);
130	__get_user(env->regs[20], &gregs[19]);
131	__get_user(env->regs[21], &gregs[20]);
132	__get_user(env->regs[22], &gregs[21]);
133	__get_user(env->regs[23], &gregs[22]);
134	/* gregs[23] is handled below */
135	/* Verify, should this be settable */
136	__get_user(env->regs[R_FP], &gregs[24]);
137	/* Verify, should this be settable */
138	__get_user(env->regs[R_GP], &gregs[25]);
139	/* Not really necessary no user settable bits */
140	__get_user(temp, &gregs[26]);
141	__get_user(env->regs[R_EA], &gregs[27]);
142
143	__get_user(env->regs[R_RA], &gregs[23]);
144	__get_user(env->regs[R_SP], &gregs[28]);
145
146	off = offsetof(struct target_rt_sigframe, uc.tuc_stack);
147	err = do_sigaltstack(frame_addr + off, 0, get_sp_from_cpustate(env));
148	if (err == -EFAULT) {
149	return 1;
150	}
151
152	*pr2 = env->regs[2];
153	return 0;
154	}
155
156	static void get_sigframe(struct target_sigaction ka, CPUNios2State *env,
157	size_t frame_size)
158	{
159	unsigned long usp;
160
161	/* Default to using normal stack. */
162	usp = env->regs[R_SP];
163
164	/* This is the X/Open sanctioned signal stack switching. */
165	usp = sigsp(usp, ka);
166
167	/* Verify, is it 32 or 64 bit aligned */
168	return (void *)((usp - frame_size) & -8UL);
169	}
170
171	void setup_rt_frame(int sig, struct target_sigaction *ka,
172	target_siginfo_t *info,
173	target_sigset_t *set,
174	CPUNios2State *env)
175	{
176	struct target_rt_sigframe *frame;
177	int i, err = 0;
178
179	frame = get_sigframe(ka, env, sizeof(*frame));
180
181	if (ka->sa_flags & SA_SIGINFO) {
182	tswap_siginfo(&frame->info, info);
183	}
184
185	/* Create the ucontext. */
186	__put_user(0, &frame->uc.tuc_flags);
187	__put_user(0, &frame->uc.tuc_link);
188	__put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp);
189	__put_user(sas_ss_flags(env->regs[R_SP]), &frame->uc.tuc_stack.ss_flags);
190	__put_user(target_sigaltstack_used.ss_size, &frame->uc.tuc_stack.ss_size);
191	err \|= rt_setup_ucontext(&frame->uc, env);
192	for (i = 0; i < TARGET_NSIG_WORDS; i++) {
193	__put_user((abi_ulong)set->sig[i],
194	(abi_ulong *)&frame->uc.tuc_sigmask.sig[i]);
195	}
196
197	if (err) {
198	goto give_sigsegv;
199	}
200
201	/* Set up to return from userspace; jump to fixed address sigreturn
202	trampoline on kuser page. */
203	env->regs[R_RA] = (unsigned long) (0x1044);
204
205	/* Set up registers for signal handler */
206	env->regs[R_SP] = (unsigned long) frame;
207	env->regs[4] = (unsigned long) sig;
208	env->regs[5] = (unsigned long) &frame->info;
209	env->regs[6] = (unsigned long) &frame->uc;
210	env->regs[R_EA] = (unsigned long) ka->_sa_handler;
211	return;
212
213	give_sigsegv:
214	if (sig == TARGET_SIGSEGV) {
215	ka->_sa_handler = TARGET_SIG_DFL;
216	}
217	force_sigsegv(sig);
218	return;
219	}
220
221	long do_sigreturn(CPUNios2State *env)
222	{
223	trace_user_do_sigreturn(env, 0);
224	fprintf(stderr, "do_sigreturn: not implemented\n");
225	return -TARGET_ENOSYS;
226	}
227
228	long do_rt_sigreturn(CPUNios2State *env)
229	{
230	/* Verify, can we follow the stack back */
231	abi_ulong frame_addr = env->regs[R_SP];
232	struct target_rt_sigframe *frame;
233	sigset_t set;
234	int rval;
235
236	if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
237	goto badframe;
238	}
239
240	target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
241	do_sigprocmask(SIG_SETMASK, &set, NULL);
242
243	if (rt_restore_ucontext(env, &frame->uc, &rval)) {
244	goto badframe;
245	}
246
247	unlock_user_struct(frame, frame_addr, 0);
248	return rval;
249
250	badframe:
251	unlock_user_struct(frame, frame_addr, 0);
252	force_sig(TARGET_SIGSEGV);
253	return 0;
254	}