blob: 919aa836fafe6840585dae8ea4161949e9950aa8 [file] [log] [blame]
bellard31e31b82003-02-18 22:55:36 +00001/*
bellard66fb9762003-03-23 01:06:05 +00002 * Emulation of Linux signals
ths5fafdf22007-09-16 21:08:06 +00003 *
bellard31e31b82003-02-18 22:55:36 +00004 * 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
Blue Swirl8167ee82009-07-16 20:47:01 +000017 * along with this program; if not, see <http://www.gnu.org/licenses/>.
bellard31e31b82003-02-18 22:55:36 +000018 */
19#include <stdlib.h>
20#include <stdio.h>
bellard66fb9762003-03-23 01:06:05 +000021#include <string.h>
bellard31e31b82003-02-18 22:55:36 +000022#include <stdarg.h>
bellard2677e102003-04-10 00:03:27 +000023#include <unistd.h>
bellard66fb9762003-03-23 01:06:05 +000024#include <errno.h>
bellard31e31b82003-02-18 22:55:36 +000025#include <sys/ucontext.h>
Mika Westerbergedf8e2a2009-04-07 09:57:11 +030026#include <sys/resource.h>
bellard31e31b82003-02-18 22:55:36 +000027
bellard3ef693a2003-03-23 20:17:16 +000028#include "qemu.h"
blueswir17d99a002009-01-14 19:00:36 +000029#include "qemu-common.h"
blueswir1992f48a2007-10-14 16:27:31 +000030#include "target_signal.h"
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +010031#include "trace.h"
bellard66fb9762003-03-23 01:06:05 +000032
blueswir1249c4c32008-10-05 11:09:37 +000033static struct target_sigaltstack target_sigaltstack_used = {
thsa04e1342007-09-27 13:57:58 +000034 .ss_sp = 0,
35 .ss_size = 0,
36 .ss_flags = TARGET_SS_DISABLE,
37};
38
pbrook624f7972008-05-31 16:11:38 +000039static struct target_sigaction sigact_table[TARGET_NSIG];
bellard31e31b82003-02-18 22:55:36 +000040
ths5fafdf22007-09-16 21:08:06 +000041static void host_signal_handler(int host_signum, siginfo_t *info,
bellard66fb9762003-03-23 01:06:05 +000042 void *puc);
43
Arnaud Patard3ca05582009-03-30 01:18:20 +020044static uint8_t host_to_target_signal_table[_NSIG] = {
bellard9e5f5282003-07-13 17:33:54 +000045 [SIGHUP] = TARGET_SIGHUP,
46 [SIGINT] = TARGET_SIGINT,
47 [SIGQUIT] = TARGET_SIGQUIT,
48 [SIGILL] = TARGET_SIGILL,
49 [SIGTRAP] = TARGET_SIGTRAP,
50 [SIGABRT] = TARGET_SIGABRT,
bellard01e3b762003-09-30 21:10:14 +000051/* [SIGIOT] = TARGET_SIGIOT,*/
bellard9e5f5282003-07-13 17:33:54 +000052 [SIGBUS] = TARGET_SIGBUS,
53 [SIGFPE] = TARGET_SIGFPE,
54 [SIGKILL] = TARGET_SIGKILL,
55 [SIGUSR1] = TARGET_SIGUSR1,
56 [SIGSEGV] = TARGET_SIGSEGV,
57 [SIGUSR2] = TARGET_SIGUSR2,
58 [SIGPIPE] = TARGET_SIGPIPE,
59 [SIGALRM] = TARGET_SIGALRM,
60 [SIGTERM] = TARGET_SIGTERM,
61#ifdef SIGSTKFLT
62 [SIGSTKFLT] = TARGET_SIGSTKFLT,
63#endif
64 [SIGCHLD] = TARGET_SIGCHLD,
65 [SIGCONT] = TARGET_SIGCONT,
66 [SIGSTOP] = TARGET_SIGSTOP,
67 [SIGTSTP] = TARGET_SIGTSTP,
68 [SIGTTIN] = TARGET_SIGTTIN,
69 [SIGTTOU] = TARGET_SIGTTOU,
70 [SIGURG] = TARGET_SIGURG,
71 [SIGXCPU] = TARGET_SIGXCPU,
72 [SIGXFSZ] = TARGET_SIGXFSZ,
73 [SIGVTALRM] = TARGET_SIGVTALRM,
74 [SIGPROF] = TARGET_SIGPROF,
75 [SIGWINCH] = TARGET_SIGWINCH,
76 [SIGIO] = TARGET_SIGIO,
77 [SIGPWR] = TARGET_SIGPWR,
78 [SIGSYS] = TARGET_SIGSYS,
79 /* next signals stay the same */
pbrook624f7972008-05-31 16:11:38 +000080 /* Nasty hack: Reverse SIGRTMIN and SIGRTMAX to avoid overlap with
Dong Xu Wangb4916d72011-11-22 18:06:17 +080081 host libpthread signals. This assumes no one actually uses SIGRTMAX :-/
pbrook624f7972008-05-31 16:11:38 +000082 To fix this properly we need to do manual signal delivery multiplexed
83 over a single host signal. */
84 [__SIGRTMIN] = __SIGRTMAX,
85 [__SIGRTMAX] = __SIGRTMIN,
bellard9e5f5282003-07-13 17:33:54 +000086};
Arnaud Patard3ca05582009-03-30 01:18:20 +020087static uint8_t target_to_host_signal_table[_NSIG];
bellard9e5f5282003-07-13 17:33:54 +000088
thsa04e1342007-09-27 13:57:58 +000089static inline int on_sig_stack(unsigned long sp)
90{
91 return (sp - target_sigaltstack_used.ss_sp
92 < target_sigaltstack_used.ss_size);
93}
94
95static inline int sas_ss_flags(unsigned long sp)
96{
97 return (target_sigaltstack_used.ss_size == 0 ? SS_DISABLE
98 : on_sig_stack(sp) ? SS_ONSTACK : 0);
99}
100
pbrook1d9d8b52009-04-16 15:17:02 +0000101int host_to_target_signal(int sig)
bellard31e31b82003-02-18 22:55:36 +0000102{
Andreas Schwab167c50d2013-07-02 14:04:12 +0100103 if (sig < 0 || sig >= _NSIG)
pbrook4cb05962008-05-30 18:05:19 +0000104 return sig;
bellard9e5f5282003-07-13 17:33:54 +0000105 return host_to_target_signal_table[sig];
bellard31e31b82003-02-18 22:55:36 +0000106}
107
pbrook4cb05962008-05-30 18:05:19 +0000108int target_to_host_signal(int sig)
bellard31e31b82003-02-18 22:55:36 +0000109{
Andreas Schwab167c50d2013-07-02 14:04:12 +0100110 if (sig < 0 || sig >= _NSIG)
pbrook4cb05962008-05-30 18:05:19 +0000111 return sig;
bellard9e5f5282003-07-13 17:33:54 +0000112 return target_to_host_signal_table[sig];
bellard31e31b82003-02-18 22:55:36 +0000113}
114
Anthony Liguoric227f092009-10-01 16:12:16 -0500115static inline void target_sigemptyset(target_sigset_t *set)
pbrookf5545b52008-05-30 22:37:07 +0000116{
117 memset(set, 0, sizeof(*set));
118}
119
Anthony Liguoric227f092009-10-01 16:12:16 -0500120static inline void target_sigaddset(target_sigset_t *set, int signum)
pbrookf5545b52008-05-30 22:37:07 +0000121{
122 signum--;
123 abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW);
124 set->sig[signum / TARGET_NSIG_BPW] |= mask;
125}
126
Anthony Liguoric227f092009-10-01 16:12:16 -0500127static inline int target_sigismember(const target_sigset_t *set, int signum)
pbrookf5545b52008-05-30 22:37:07 +0000128{
129 signum--;
130 abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW);
131 return ((set->sig[signum / TARGET_NSIG_BPW] & mask) != 0);
132}
133
Anthony Liguoric227f092009-10-01 16:12:16 -0500134static void host_to_target_sigset_internal(target_sigset_t *d,
bellard92319442004-06-19 16:58:13 +0000135 const sigset_t *s)
bellard66fb9762003-03-23 01:06:05 +0000136{
137 int i;
pbrookf5545b52008-05-30 22:37:07 +0000138 target_sigemptyset(d);
139 for (i = 1; i <= TARGET_NSIG; i++) {
140 if (sigismember(s, i)) {
141 target_sigaddset(d, host_to_target_signal(i));
142 }
bellard9e5f5282003-07-13 17:33:54 +0000143 }
bellard66fb9762003-03-23 01:06:05 +0000144}
145
Anthony Liguoric227f092009-10-01 16:12:16 -0500146void host_to_target_sigset(target_sigset_t *d, const sigset_t *s)
bellard92319442004-06-19 16:58:13 +0000147{
Anthony Liguoric227f092009-10-01 16:12:16 -0500148 target_sigset_t d1;
bellard92319442004-06-19 16:58:13 +0000149 int i;
150
151 host_to_target_sigset_internal(&d1, s);
152 for(i = 0;i < TARGET_NSIG_WORDS; i++)
Matthias Brauncbb21ee2011-08-12 19:57:41 +0200153 d->sig[i] = tswapal(d1.sig[i]);
bellard92319442004-06-19 16:58:13 +0000154}
155
blueswir18fcd3692008-08-17 20:26:25 +0000156static void target_to_host_sigset_internal(sigset_t *d,
Anthony Liguoric227f092009-10-01 16:12:16 -0500157 const target_sigset_t *s)
bellard66fb9762003-03-23 01:06:05 +0000158{
159 int i;
pbrookf5545b52008-05-30 22:37:07 +0000160 sigemptyset(d);
161 for (i = 1; i <= TARGET_NSIG; i++) {
162 if (target_sigismember(s, i)) {
163 sigaddset(d, target_to_host_signal(i));
164 }
165 }
bellard66fb9762003-03-23 01:06:05 +0000166}
167
Anthony Liguoric227f092009-10-01 16:12:16 -0500168void target_to_host_sigset(sigset_t *d, const target_sigset_t *s)
bellard92319442004-06-19 16:58:13 +0000169{
Anthony Liguoric227f092009-10-01 16:12:16 -0500170 target_sigset_t s1;
bellard92319442004-06-19 16:58:13 +0000171 int i;
172
173 for(i = 0;i < TARGET_NSIG_WORDS; i++)
Matthias Brauncbb21ee2011-08-12 19:57:41 +0200174 s1.sig[i] = tswapal(s->sig[i]);
bellard92319442004-06-19 16:58:13 +0000175 target_to_host_sigset_internal(d, &s1);
176}
ths3b46e622007-09-17 08:09:54 +0000177
blueswir1992f48a2007-10-14 16:27:31 +0000178void host_to_target_old_sigset(abi_ulong *old_sigset,
bellard66fb9762003-03-23 01:06:05 +0000179 const sigset_t *sigset)
180{
Anthony Liguoric227f092009-10-01 16:12:16 -0500181 target_sigset_t d;
bellard9e5f5282003-07-13 17:33:54 +0000182 host_to_target_sigset(&d, sigset);
183 *old_sigset = d.sig[0];
bellard66fb9762003-03-23 01:06:05 +0000184}
185
ths5fafdf22007-09-16 21:08:06 +0000186void target_to_host_old_sigset(sigset_t *sigset,
blueswir1992f48a2007-10-14 16:27:31 +0000187 const abi_ulong *old_sigset)
bellard66fb9762003-03-23 01:06:05 +0000188{
Anthony Liguoric227f092009-10-01 16:12:16 -0500189 target_sigset_t d;
bellard9e5f5282003-07-13 17:33:54 +0000190 int i;
191
192 d.sig[0] = *old_sigset;
193 for(i = 1;i < TARGET_NSIG_WORDS; i++)
194 d.sig[i] = 0;
195 target_to_host_sigset(sigset, &d);
bellard66fb9762003-03-23 01:06:05 +0000196}
197
Alex Barcelo1c275922014-03-14 14:36:55 +0000198/* Wrapper for sigprocmask function
199 * Emulates a sigprocmask in a safe way for the guest. Note that set and oldset
200 * are host signal set, not guest ones. This wraps the sigprocmask host calls
201 * that should be protected (calls originated from guest)
202 */
203int do_sigprocmask(int how, const sigset_t *set, sigset_t *oldset)
204{
Peter Maydella7ec0f92014-03-14 14:36:56 +0000205 int ret;
206 sigset_t val;
207 sigset_t *temp = NULL;
208 CPUState *cpu = thread_cpu;
209 TaskState *ts = (TaskState *)cpu->opaque;
210 bool segv_was_blocked = ts->sigsegv_blocked;
211
212 if (set) {
213 bool has_sigsegv = sigismember(set, SIGSEGV);
214 val = *set;
215 temp = &val;
216
217 sigdelset(temp, SIGSEGV);
218
219 switch (how) {
220 case SIG_BLOCK:
221 if (has_sigsegv) {
222 ts->sigsegv_blocked = true;
223 }
224 break;
225 case SIG_UNBLOCK:
226 if (has_sigsegv) {
227 ts->sigsegv_blocked = false;
228 }
229 break;
230 case SIG_SETMASK:
231 ts->sigsegv_blocked = has_sigsegv;
232 break;
233 default:
234 g_assert_not_reached();
235 }
236 }
237
238 ret = sigprocmask(how, temp, oldset);
239
240 if (oldset && segv_was_blocked) {
241 sigaddset(oldset, SIGSEGV);
242 }
243
244 return ret;
Alex Barcelo1c275922014-03-14 14:36:55 +0000245}
246
bellard9de5e442003-03-23 16:49:39 +0000247/* siginfo conversion */
248
Anthony Liguoric227f092009-10-01 16:12:16 -0500249static inline void host_to_target_siginfo_noswap(target_siginfo_t *tinfo,
bellard9de5e442003-03-23 16:49:39 +0000250 const siginfo_t *info)
bellard66fb9762003-03-23 01:06:05 +0000251{
Richard Hendersona05c6402012-09-15 11:34:20 -0700252 int sig = host_to_target_signal(info->si_signo);
bellard9de5e442003-03-23 16:49:39 +0000253 tinfo->si_signo = sig;
254 tinfo->si_errno = 0;
pbrookafd7cd92008-05-31 12:14:21 +0000255 tinfo->si_code = info->si_code;
Richard Hendersona05c6402012-09-15 11:34:20 -0700256
257 if (sig == TARGET_SIGILL || sig == TARGET_SIGFPE || sig == TARGET_SIGSEGV
258 || sig == TARGET_SIGBUS || sig == TARGET_SIGTRAP) {
259 /* Should never come here, but who knows. The information for
260 the target is irrelevant. */
bellard9de5e442003-03-23 16:49:39 +0000261 tinfo->_sifields._sigfault._addr = 0;
Richard Hendersona05c6402012-09-15 11:34:20 -0700262 } else if (sig == TARGET_SIGIO) {
263 tinfo->_sifields._sigpoll._band = info->si_band;
ths7f7f7c82007-07-12 11:02:46 +0000264 tinfo->_sifields._sigpoll._fd = info->si_fd;
Richard Hendersona05c6402012-09-15 11:34:20 -0700265 } else if (sig == TARGET_SIGCHLD) {
266 tinfo->_sifields._sigchld._pid = info->si_pid;
267 tinfo->_sifields._sigchld._uid = info->si_uid;
268 tinfo->_sifields._sigchld._status
269 = host_to_target_waitstatus(info->si_status);
270 tinfo->_sifields._sigchld._utime = info->si_utime;
271 tinfo->_sifields._sigchld._stime = info->si_stime;
bellard9de5e442003-03-23 16:49:39 +0000272 } else if (sig >= TARGET_SIGRTMIN) {
273 tinfo->_sifields._rt._pid = info->si_pid;
274 tinfo->_sifields._rt._uid = info->si_uid;
275 /* XXX: potential problem if 64 bit */
Richard Hendersona05c6402012-09-15 11:34:20 -0700276 tinfo->_sifields._rt._sigval.sival_ptr
277 = (abi_ulong)(unsigned long)info->si_value.sival_ptr;
bellard9de5e442003-03-23 16:49:39 +0000278 }
bellard66fb9762003-03-23 01:06:05 +0000279}
280
Anthony Liguoric227f092009-10-01 16:12:16 -0500281static void tswap_siginfo(target_siginfo_t *tinfo,
282 const target_siginfo_t *info)
bellard9de5e442003-03-23 16:49:39 +0000283{
Richard Hendersona05c6402012-09-15 11:34:20 -0700284 int sig = info->si_signo;
bellard9de5e442003-03-23 16:49:39 +0000285 tinfo->si_signo = tswap32(sig);
286 tinfo->si_errno = tswap32(info->si_errno);
287 tinfo->si_code = tswap32(info->si_code);
Richard Hendersona05c6402012-09-15 11:34:20 -0700288
289 if (sig == TARGET_SIGILL || sig == TARGET_SIGFPE || sig == TARGET_SIGSEGV
290 || sig == TARGET_SIGBUS || sig == TARGET_SIGTRAP) {
291 tinfo->_sifields._sigfault._addr
292 = tswapal(info->_sifields._sigfault._addr);
293 } else if (sig == TARGET_SIGIO) {
294 tinfo->_sifields._sigpoll._band
295 = tswap32(info->_sifields._sigpoll._band);
296 tinfo->_sifields._sigpoll._fd = tswap32(info->_sifields._sigpoll._fd);
297 } else if (sig == TARGET_SIGCHLD) {
298 tinfo->_sifields._sigchld._pid
299 = tswap32(info->_sifields._sigchld._pid);
300 tinfo->_sifields._sigchld._uid
301 = tswap32(info->_sifields._sigchld._uid);
302 tinfo->_sifields._sigchld._status
303 = tswap32(info->_sifields._sigchld._status);
304 tinfo->_sifields._sigchld._utime
305 = tswapal(info->_sifields._sigchld._utime);
306 tinfo->_sifields._sigchld._stime
307 = tswapal(info->_sifields._sigchld._stime);
bellard9de5e442003-03-23 16:49:39 +0000308 } else if (sig >= TARGET_SIGRTMIN) {
309 tinfo->_sifields._rt._pid = tswap32(info->_sifields._rt._pid);
310 tinfo->_sifields._rt._uid = tswap32(info->_sifields._rt._uid);
Richard Hendersona05c6402012-09-15 11:34:20 -0700311 tinfo->_sifields._rt._sigval.sival_ptr
312 = tswapal(info->_sifields._rt._sigval.sival_ptr);
bellard9de5e442003-03-23 16:49:39 +0000313 }
314}
315
316
Anthony Liguoric227f092009-10-01 16:12:16 -0500317void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info)
bellard9de5e442003-03-23 16:49:39 +0000318{
319 host_to_target_siginfo_noswap(tinfo, info);
320 tswap_siginfo(tinfo, tinfo);
321}
322
323/* XXX: we support only POSIX RT signals are used. */
thsaa1f17c2007-07-11 22:48:58 +0000324/* XXX: find a solution for 64 bit (additional malloced data is needed) */
Anthony Liguoric227f092009-10-01 16:12:16 -0500325void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo)
bellard66fb9762003-03-23 01:06:05 +0000326{
327 info->si_signo = tswap32(tinfo->si_signo);
328 info->si_errno = tswap32(tinfo->si_errno);
329 info->si_code = tswap32(tinfo->si_code);
bellard9de5e442003-03-23 16:49:39 +0000330 info->si_pid = tswap32(tinfo->_sifields._rt._pid);
331 info->si_uid = tswap32(tinfo->_sifields._rt._uid);
ths5fafdf22007-09-16 21:08:06 +0000332 info->si_value.sival_ptr =
Matthias Brauncbb21ee2011-08-12 19:57:41 +0200333 (void *)(long)tswapal(tinfo->_sifields._rt._sigval.sival_ptr);
bellard66fb9762003-03-23 01:06:05 +0000334}
335
aurel32ca587a82008-12-18 22:44:13 +0000336static int fatal_signal (int sig)
337{
338 switch (sig) {
339 case TARGET_SIGCHLD:
340 case TARGET_SIGURG:
341 case TARGET_SIGWINCH:
342 /* Ignored by default. */
343 return 0;
344 case TARGET_SIGCONT:
345 case TARGET_SIGSTOP:
346 case TARGET_SIGTSTP:
347 case TARGET_SIGTTIN:
348 case TARGET_SIGTTOU:
349 /* Job control signals. */
350 return 0;
351 default:
352 return 1;
353 }
354}
355
Mika Westerbergedf8e2a2009-04-07 09:57:11 +0300356/* returns 1 if given signal should dump core if not handled */
357static int core_dump_signal(int sig)
358{
359 switch (sig) {
360 case TARGET_SIGABRT:
361 case TARGET_SIGFPE:
362 case TARGET_SIGILL:
363 case TARGET_SIGQUIT:
364 case TARGET_SIGSEGV:
365 case TARGET_SIGTRAP:
366 case TARGET_SIGBUS:
367 return (1);
368 default:
369 return (0);
370 }
371}
372
bellard31e31b82003-02-18 22:55:36 +0000373void signal_init(void)
374{
375 struct sigaction act;
pbrook624f7972008-05-31 16:11:38 +0000376 struct sigaction oact;
bellard9e5f5282003-07-13 17:33:54 +0000377 int i, j;
pbrook624f7972008-05-31 16:11:38 +0000378 int host_sig;
bellard31e31b82003-02-18 22:55:36 +0000379
bellard9e5f5282003-07-13 17:33:54 +0000380 /* generate signal conversion tables */
Arnaud Patard3ca05582009-03-30 01:18:20 +0200381 for(i = 1; i < _NSIG; i++) {
bellard9e5f5282003-07-13 17:33:54 +0000382 if (host_to_target_signal_table[i] == 0)
383 host_to_target_signal_table[i] = i;
384 }
Arnaud Patard3ca05582009-03-30 01:18:20 +0200385 for(i = 1; i < _NSIG; i++) {
bellard9e5f5282003-07-13 17:33:54 +0000386 j = host_to_target_signal_table[i];
387 target_to_host_signal_table[j] = i;
388 }
ths3b46e622007-09-17 08:09:54 +0000389
bellard9de5e442003-03-23 16:49:39 +0000390 /* set all host signal handlers. ALL signals are blocked during
391 the handlers to serialize them. */
pbrook624f7972008-05-31 16:11:38 +0000392 memset(sigact_table, 0, sizeof(sigact_table));
393
bellard9de5e442003-03-23 16:49:39 +0000394 sigfillset(&act.sa_mask);
bellard31e31b82003-02-18 22:55:36 +0000395 act.sa_flags = SA_SIGINFO;
396 act.sa_sigaction = host_signal_handler;
pbrook624f7972008-05-31 16:11:38 +0000397 for(i = 1; i <= TARGET_NSIG; i++) {
398 host_sig = target_to_host_signal(i);
399 sigaction(host_sig, NULL, &oact);
400 if (oact.sa_sigaction == (void *)SIG_IGN) {
401 sigact_table[i - 1]._sa_handler = TARGET_SIG_IGN;
402 } else if (oact.sa_sigaction == (void *)SIG_DFL) {
403 sigact_table[i - 1]._sa_handler = TARGET_SIG_DFL;
404 }
405 /* If there's already a handler installed then something has
406 gone horribly wrong, so don't even try to handle that case. */
aurel32ca587a82008-12-18 22:44:13 +0000407 /* Install some handlers for our own use. We need at least
408 SIGSEGV and SIGBUS, to detect exceptions. We can not just
409 trap all signals because it affects syscall interrupt
410 behavior. But do trap all default-fatal signals. */
411 if (fatal_signal (i))
pbrook624f7972008-05-31 16:11:38 +0000412 sigaction(host_sig, &act, NULL);
bellard31e31b82003-02-18 22:55:36 +0000413 }
bellard31e31b82003-02-18 22:55:36 +0000414}
415
bellard66fb9762003-03-23 01:06:05 +0000416/* signal queue handling */
417
Andreas Färber9349b4f2012-03-14 01:38:32 +0100418static inline struct sigqueue *alloc_sigqueue(CPUArchState *env)
bellard66fb9762003-03-23 01:06:05 +0000419{
Andreas Färber0429a972013-08-26 18:14:44 +0200420 CPUState *cpu = ENV_GET_CPU(env);
421 TaskState *ts = cpu->opaque;
pbrook624f7972008-05-31 16:11:38 +0000422 struct sigqueue *q = ts->first_free;
bellard66fb9762003-03-23 01:06:05 +0000423 if (!q)
424 return NULL;
pbrook624f7972008-05-31 16:11:38 +0000425 ts->first_free = q->next;
bellard66fb9762003-03-23 01:06:05 +0000426 return q;
427}
428
Andreas Färber9349b4f2012-03-14 01:38:32 +0100429static inline void free_sigqueue(CPUArchState *env, struct sigqueue *q)
bellard66fb9762003-03-23 01:06:05 +0000430{
Andreas Färber0429a972013-08-26 18:14:44 +0200431 CPUState *cpu = ENV_GET_CPU(env);
432 TaskState *ts = cpu->opaque;
433
pbrook624f7972008-05-31 16:11:38 +0000434 q->next = ts->first_free;
435 ts->first_free = q;
bellard66fb9762003-03-23 01:06:05 +0000436}
437
bellard9de5e442003-03-23 16:49:39 +0000438/* abort execution with signal */
Riku Voipio66393fb2009-12-04 15:16:32 +0200439static void QEMU_NORETURN force_sig(int target_sig)
bellard66fb9762003-03-23 01:06:05 +0000440{
Andreas Färber0429a972013-08-26 18:14:44 +0200441 CPUState *cpu = thread_cpu;
442 CPUArchState *env = cpu->env_ptr;
443 TaskState *ts = (TaskState *)cpu->opaque;
Mika Westerbergedf8e2a2009-04-07 09:57:11 +0300444 int host_sig, core_dumped = 0;
aurel32603e4fd2009-04-15 16:18:38 +0000445 struct sigaction act;
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +0100446
Riku Voipio66393fb2009-12-04 15:16:32 +0200447 host_sig = target_to_host_signal(target_sig);
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +0100448 trace_user_force_sig(env, target_sig, host_sig);
Andreas Färbera2247f82013-06-09 19:47:04 +0200449 gdb_signalled(env, target_sig);
aurel32603e4fd2009-04-15 16:18:38 +0000450
Mika Westerbergedf8e2a2009-04-07 09:57:11 +0300451 /* dump core if supported by target binary format */
Riku Voipio66393fb2009-12-04 15:16:32 +0200452 if (core_dump_signal(target_sig) && (ts->bprm->core_dump != NULL)) {
Mika Westerbergedf8e2a2009-04-07 09:57:11 +0300453 stop_all_tasks();
454 core_dumped =
Andreas Färbera2247f82013-06-09 19:47:04 +0200455 ((*ts->bprm->core_dump)(target_sig, env) == 0);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +0300456 }
457 if (core_dumped) {
458 /* we already dumped the core of target process, we don't want
459 * a coredump of qemu itself */
460 struct rlimit nodump;
461 getrlimit(RLIMIT_CORE, &nodump);
462 nodump.rlim_cur=0;
463 setrlimit(RLIMIT_CORE, &nodump);
464 (void) fprintf(stderr, "qemu: uncaught target signal %d (%s) - %s\n",
Riku Voipio66393fb2009-12-04 15:16:32 +0200465 target_sig, strsignal(host_sig), "core dumped" );
Mika Westerbergedf8e2a2009-04-07 09:57:11 +0300466 }
467
Stefan Weil0c587512011-04-28 17:20:32 +0200468 /* The proper exit code for dying from an uncaught signal is
aurel32603e4fd2009-04-15 16:18:38 +0000469 * -<signal>. The kernel doesn't allow exit() or _exit() to pass
470 * a negative value. To get the proper exit code we need to
471 * actually die from an uncaught signal. Here the default signal
472 * handler is installed, we send ourself a signal and we wait for
473 * it to arrive. */
474 sigfillset(&act.sa_mask);
475 act.sa_handler = SIG_DFL;
Peter Maydell3a5d30b2014-02-17 18:55:32 +0000476 act.sa_flags = 0;
aurel32603e4fd2009-04-15 16:18:38 +0000477 sigaction(host_sig, &act, NULL);
478
479 /* For some reason raise(host_sig) doesn't send the signal when
480 * statically linked on x86-64. */
481 kill(getpid(), host_sig);
482
483 /* Make sure the signal isn't masked (just reuse the mask inside
484 of act) */
485 sigdelset(&act.sa_mask, host_sig);
486 sigsuspend(&act.sa_mask);
487
488 /* unreachable */
Blue Swirla6c6f762010-03-13 14:18:50 +0000489 abort();
bellard66fb9762003-03-23 01:06:05 +0000490}
491
bellard9de5e442003-03-23 16:49:39 +0000492/* queue a signal so that it will be send to the virtual CPU as soon
493 as possible */
Andreas Färber9349b4f2012-03-14 01:38:32 +0100494int queue_signal(CPUArchState *env, int sig, target_siginfo_t *info)
bellard31e31b82003-02-18 22:55:36 +0000495{
Andreas Färber0429a972013-08-26 18:14:44 +0200496 CPUState *cpu = ENV_GET_CPU(env);
497 TaskState *ts = cpu->opaque;
pbrook624f7972008-05-31 16:11:38 +0000498 struct emulated_sigtable *k;
bellard9de5e442003-03-23 16:49:39 +0000499 struct sigqueue *q, **pq;
blueswir1992f48a2007-10-14 16:27:31 +0000500 abi_ulong handler;
aurel32ca587a82008-12-18 22:44:13 +0000501 int queue;
bellard66fb9762003-03-23 01:06:05 +0000502
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +0100503 trace_user_queue_signal(env, sig);
pbrook624f7972008-05-31 16:11:38 +0000504 k = &ts->sigtab[sig - 1];
aurel32ca587a82008-12-18 22:44:13 +0000505 queue = gdb_queuesig ();
pbrook624f7972008-05-31 16:11:38 +0000506 handler = sigact_table[sig - 1]._sa_handler;
Peter Maydella7ec0f92014-03-14 14:36:56 +0000507
508 if (ts->sigsegv_blocked && sig == TARGET_SIGSEGV) {
509 /* Guest has blocked SIGSEGV but we got one anyway. Assume this
510 * is a forced SIGSEGV (ie one the kernel handles via force_sig_info
511 * because it got a real MMU fault). A blocked SIGSEGV in that
512 * situation is treated as if using the default handler. This is
513 * not correct if some other process has randomly sent us a SIGSEGV
514 * via kill(), but that is not easy to distinguish at this point,
515 * so we assume it doesn't happen.
516 */
517 handler = TARGET_SIG_DFL;
518 }
519
aurel32ca587a82008-12-18 22:44:13 +0000520 if (!queue && handler == TARGET_SIG_DFL) {
ths60b19692008-11-27 15:47:15 +0000521 if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) {
522 kill(getpid(),SIGSTOP);
523 return 0;
524 } else
bellard66fb9762003-03-23 01:06:05 +0000525 /* default handler : ignore some signal. The other are fatal */
ths5fafdf22007-09-16 21:08:06 +0000526 if (sig != TARGET_SIGCHLD &&
527 sig != TARGET_SIGURG &&
ths60b19692008-11-27 15:47:15 +0000528 sig != TARGET_SIGWINCH &&
529 sig != TARGET_SIGCONT) {
bellard66fb9762003-03-23 01:06:05 +0000530 force_sig(sig);
bellard9de5e442003-03-23 16:49:39 +0000531 } else {
532 return 0; /* indicate ignored */
bellard66fb9762003-03-23 01:06:05 +0000533 }
aurel32ca587a82008-12-18 22:44:13 +0000534 } else if (!queue && handler == TARGET_SIG_IGN) {
bellard66fb9762003-03-23 01:06:05 +0000535 /* ignore signal */
bellard9de5e442003-03-23 16:49:39 +0000536 return 0;
aurel32ca587a82008-12-18 22:44:13 +0000537 } else if (!queue && handler == TARGET_SIG_ERR) {
bellard66fb9762003-03-23 01:06:05 +0000538 force_sig(sig);
539 } else {
bellard9de5e442003-03-23 16:49:39 +0000540 pq = &k->first;
541 if (sig < TARGET_SIGRTMIN) {
542 /* if non real time signal, we queue exactly one signal */
543 if (!k->pending)
544 q = &k->info;
545 else
546 return 0;
547 } else {
548 if (!k->pending) {
549 /* first signal */
550 q = &k->info;
551 } else {
pbrook624f7972008-05-31 16:11:38 +0000552 q = alloc_sigqueue(env);
bellard9de5e442003-03-23 16:49:39 +0000553 if (!q)
554 return -EAGAIN;
555 while (*pq != NULL)
556 pq = &(*pq)->next;
557 }
558 }
559 *pq = q;
560 q->info = *info;
561 q->next = NULL;
562 k->pending = 1;
563 /* signal that a new signal is pending */
pbrook624f7972008-05-31 16:11:38 +0000564 ts->signal_pending = 1;
bellard9de5e442003-03-23 16:49:39 +0000565 return 1; /* indicates that the signal was queued */
566 }
567}
568
ths5fafdf22007-09-16 21:08:06 +0000569static void host_signal_handler(int host_signum, siginfo_t *info,
bellard9de5e442003-03-23 16:49:39 +0000570 void *puc)
571{
Andreas Färbera2247f82013-06-09 19:47:04 +0200572 CPUArchState *env = thread_cpu->env_ptr;
bellard9de5e442003-03-23 16:49:39 +0000573 int sig;
Anthony Liguoric227f092009-10-01 16:12:16 -0500574 target_siginfo_t tinfo;
bellard9de5e442003-03-23 16:49:39 +0000575
576 /* the CPU emulator uses some host signals to detect exceptions,
aurel32eaa449b2009-01-03 13:14:52 +0000577 we forward to it some signals */
aurel32ca587a82008-12-18 22:44:13 +0000578 if ((host_signum == SIGSEGV || host_signum == SIGBUS)
aurel32eaa449b2009-01-03 13:14:52 +0000579 && info->si_code > 0) {
bellardb346ff42003-06-15 20:05:50 +0000580 if (cpu_signal_handler(host_signum, info, puc))
bellard9de5e442003-03-23 16:49:39 +0000581 return;
582 }
583
584 /* get target signal number */
585 sig = host_to_target_signal(host_signum);
586 if (sig < 1 || sig > TARGET_NSIG)
587 return;
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +0100588 trace_user_host_signal(env, host_signum, sig);
bellard9de5e442003-03-23 16:49:39 +0000589 host_to_target_siginfo_noswap(&tinfo, info);
Andreas Färbera2247f82013-06-09 19:47:04 +0200590 if (queue_signal(env, sig, &tinfo) == 1) {
bellard9de5e442003-03-23 16:49:39 +0000591 /* interrupt the virtual CPU as soon as possible */
Andreas Färbera2247f82013-06-09 19:47:04 +0200592 cpu_exit(thread_cpu);
bellard66fb9762003-03-23 01:06:05 +0000593 }
bellard31e31b82003-02-18 22:55:36 +0000594}
595
ths0da46a62007-10-20 20:23:07 +0000596/* do_sigaltstack() returns target values and errnos. */
bellard579a97f2007-11-11 14:26:47 +0000597/* compare linux/kernel/signal.c:do_sigaltstack() */
598abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp)
thsa04e1342007-09-27 13:57:58 +0000599{
600 int ret;
601 struct target_sigaltstack oss;
602
603 /* XXX: test errors */
bellard579a97f2007-11-11 14:26:47 +0000604 if(uoss_addr)
thsa04e1342007-09-27 13:57:58 +0000605 {
606 __put_user(target_sigaltstack_used.ss_sp, &oss.ss_sp);
607 __put_user(target_sigaltstack_used.ss_size, &oss.ss_size);
608 __put_user(sas_ss_flags(sp), &oss.ss_flags);
609 }
610
bellard579a97f2007-11-11 14:26:47 +0000611 if(uss_addr)
thsa04e1342007-09-27 13:57:58 +0000612 {
bellard579a97f2007-11-11 14:26:47 +0000613 struct target_sigaltstack *uss;
614 struct target_sigaltstack ss;
Tom Musta0903c8b2014-08-12 13:53:40 -0500615 size_t minstacksize = TARGET_MINSIGSTKSZ;
616
617#if defined(TARGET_PPC64)
618 /* ELF V2 for PPC64 has a 4K minimum stack size for signal handlers */
619 struct image_info *image = ((TaskState *)thread_cpu->opaque)->info;
620 if (get_ppc64_abi(image) > 1) {
621 minstacksize = 4096;
622 }
623#endif
thsa04e1342007-09-27 13:57:58 +0000624
ths0da46a62007-10-20 20:23:07 +0000625 ret = -TARGET_EFAULT;
Riku Voipio9eeb8302014-04-23 11:26:34 +0300626 if (!lock_user_struct(VERIFY_READ, uss, uss_addr, 1)) {
thsa04e1342007-09-27 13:57:58 +0000627 goto out;
Riku Voipio9eeb8302014-04-23 11:26:34 +0300628 }
629 __get_user(ss.ss_sp, &uss->ss_sp);
630 __get_user(ss.ss_size, &uss->ss_size);
631 __get_user(ss.ss_flags, &uss->ss_flags);
bellard579a97f2007-11-11 14:26:47 +0000632 unlock_user_struct(uss, uss_addr, 0);
thsa04e1342007-09-27 13:57:58 +0000633
ths0da46a62007-10-20 20:23:07 +0000634 ret = -TARGET_EPERM;
thsa04e1342007-09-27 13:57:58 +0000635 if (on_sig_stack(sp))
636 goto out;
637
ths0da46a62007-10-20 20:23:07 +0000638 ret = -TARGET_EINVAL;
thsa04e1342007-09-27 13:57:58 +0000639 if (ss.ss_flags != TARGET_SS_DISABLE
640 && ss.ss_flags != TARGET_SS_ONSTACK
641 && ss.ss_flags != 0)
642 goto out;
643
644 if (ss.ss_flags == TARGET_SS_DISABLE) {
645 ss.ss_size = 0;
646 ss.ss_sp = 0;
647 } else {
ths0da46a62007-10-20 20:23:07 +0000648 ret = -TARGET_ENOMEM;
Tom Musta0903c8b2014-08-12 13:53:40 -0500649 if (ss.ss_size < minstacksize) {
thsa04e1342007-09-27 13:57:58 +0000650 goto out;
Tom Musta0903c8b2014-08-12 13:53:40 -0500651 }
thsa04e1342007-09-27 13:57:58 +0000652 }
653
654 target_sigaltstack_used.ss_sp = ss.ss_sp;
655 target_sigaltstack_used.ss_size = ss.ss_size;
656 }
657
bellard579a97f2007-11-11 14:26:47 +0000658 if (uoss_addr) {
ths0da46a62007-10-20 20:23:07 +0000659 ret = -TARGET_EFAULT;
bellard579a97f2007-11-11 14:26:47 +0000660 if (copy_to_user(uoss_addr, &oss, sizeof(oss)))
thsa04e1342007-09-27 13:57:58 +0000661 goto out;
thsa04e1342007-09-27 13:57:58 +0000662 }
663
664 ret = 0;
665out:
666 return ret;
667}
668
ths0da46a62007-10-20 20:23:07 +0000669/* do_sigaction() return host values and errnos */
bellard66fb9762003-03-23 01:06:05 +0000670int do_sigaction(int sig, const struct target_sigaction *act,
671 struct target_sigaction *oact)
bellard31e31b82003-02-18 22:55:36 +0000672{
pbrook624f7972008-05-31 16:11:38 +0000673 struct target_sigaction *k;
bellard773b93e2004-01-04 17:15:59 +0000674 struct sigaction act1;
675 int host_sig;
ths0da46a62007-10-20 20:23:07 +0000676 int ret = 0;
bellard31e31b82003-02-18 22:55:36 +0000677
ths2a913eb2008-11-27 15:46:25 +0000678 if (sig < 1 || sig > TARGET_NSIG || sig == TARGET_SIGKILL || sig == TARGET_SIGSTOP)
bellard66fb9762003-03-23 01:06:05 +0000679 return -EINVAL;
680 k = &sigact_table[sig - 1];
bellard66fb9762003-03-23 01:06:05 +0000681 if (oact) {
Richard Hendersond2565872013-01-04 16:39:32 -0800682 __put_user(k->_sa_handler, &oact->_sa_handler);
683 __put_user(k->sa_flags, &oact->sa_flags);
ths388bb212007-05-13 13:58:00 +0000684#if !defined(TARGET_MIPS)
Richard Hendersond2565872013-01-04 16:39:32 -0800685 __put_user(k->sa_restorer, &oact->sa_restorer);
ths388bb212007-05-13 13:58:00 +0000686#endif
Richard Hendersond2565872013-01-04 16:39:32 -0800687 /* Not swapped. */
pbrook624f7972008-05-31 16:11:38 +0000688 oact->sa_mask = k->sa_mask;
bellard66fb9762003-03-23 01:06:05 +0000689 }
690 if (act) {
pbrook624f7972008-05-31 16:11:38 +0000691 /* FIXME: This is not threadsafe. */
Richard Hendersond2565872013-01-04 16:39:32 -0800692 __get_user(k->_sa_handler, &act->_sa_handler);
693 __get_user(k->sa_flags, &act->sa_flags);
ths388bb212007-05-13 13:58:00 +0000694#if !defined(TARGET_MIPS)
Richard Hendersond2565872013-01-04 16:39:32 -0800695 __get_user(k->sa_restorer, &act->sa_restorer);
ths388bb212007-05-13 13:58:00 +0000696#endif
Richard Hendersond2565872013-01-04 16:39:32 -0800697 /* To be swapped in target_to_host_sigset. */
pbrook624f7972008-05-31 16:11:38 +0000698 k->sa_mask = act->sa_mask;
bellard773b93e2004-01-04 17:15:59 +0000699
700 /* we update the host linux signal state */
701 host_sig = target_to_host_signal(sig);
702 if (host_sig != SIGSEGV && host_sig != SIGBUS) {
703 sigfillset(&act1.sa_mask);
704 act1.sa_flags = SA_SIGINFO;
pbrook624f7972008-05-31 16:11:38 +0000705 if (k->sa_flags & TARGET_SA_RESTART)
bellard773b93e2004-01-04 17:15:59 +0000706 act1.sa_flags |= SA_RESTART;
707 /* NOTE: it is important to update the host kernel signal
708 ignore state to avoid getting unexpected interrupted
709 syscalls */
pbrook624f7972008-05-31 16:11:38 +0000710 if (k->_sa_handler == TARGET_SIG_IGN) {
bellard773b93e2004-01-04 17:15:59 +0000711 act1.sa_sigaction = (void *)SIG_IGN;
pbrook624f7972008-05-31 16:11:38 +0000712 } else if (k->_sa_handler == TARGET_SIG_DFL) {
aurel32ca587a82008-12-18 22:44:13 +0000713 if (fatal_signal (sig))
714 act1.sa_sigaction = host_signal_handler;
715 else
716 act1.sa_sigaction = (void *)SIG_DFL;
bellard773b93e2004-01-04 17:15:59 +0000717 } else {
718 act1.sa_sigaction = host_signal_handler;
719 }
ths0da46a62007-10-20 20:23:07 +0000720 ret = sigaction(host_sig, &act1, NULL);
bellard773b93e2004-01-04 17:15:59 +0000721 }
bellard66fb9762003-03-23 01:06:05 +0000722 }
ths0da46a62007-10-20 20:23:07 +0000723 return ret;
bellard66fb9762003-03-23 01:06:05 +0000724}
bellard31e31b82003-02-18 22:55:36 +0000725
bellard459a4012007-11-11 19:45:10 +0000726#if defined(TARGET_I386) && TARGET_ABI_BITS == 32
bellard66fb9762003-03-23 01:06:05 +0000727
728/* from the Linux kernel */
729
730struct target_fpreg {
731 uint16_t significand[4];
732 uint16_t exponent;
733};
734
735struct target_fpxreg {
736 uint16_t significand[4];
737 uint16_t exponent;
738 uint16_t padding[3];
739};
740
741struct target_xmmreg {
blueswir1992f48a2007-10-14 16:27:31 +0000742 abi_ulong element[4];
bellard66fb9762003-03-23 01:06:05 +0000743};
744
745struct target_fpstate {
746 /* Regular FPU environment */
blueswir1992f48a2007-10-14 16:27:31 +0000747 abi_ulong cw;
748 abi_ulong sw;
749 abi_ulong tag;
750 abi_ulong ipoff;
751 abi_ulong cssel;
752 abi_ulong dataoff;
753 abi_ulong datasel;
bellard66fb9762003-03-23 01:06:05 +0000754 struct target_fpreg _st[8];
755 uint16_t status;
756 uint16_t magic; /* 0xffff = regular FPU data only */
757
758 /* FXSR FPU environment */
blueswir1992f48a2007-10-14 16:27:31 +0000759 abi_ulong _fxsr_env[6]; /* FXSR FPU env is ignored */
760 abi_ulong mxcsr;
761 abi_ulong reserved;
bellard66fb9762003-03-23 01:06:05 +0000762 struct target_fpxreg _fxsr_st[8]; /* FXSR FPU reg data is ignored */
763 struct target_xmmreg _xmm[8];
blueswir1992f48a2007-10-14 16:27:31 +0000764 abi_ulong padding[56];
bellard66fb9762003-03-23 01:06:05 +0000765};
766
767#define X86_FXSR_MAGIC 0x0000
768
769struct target_sigcontext {
770 uint16_t gs, __gsh;
771 uint16_t fs, __fsh;
772 uint16_t es, __esh;
773 uint16_t ds, __dsh;
blueswir1992f48a2007-10-14 16:27:31 +0000774 abi_ulong edi;
775 abi_ulong esi;
776 abi_ulong ebp;
777 abi_ulong esp;
778 abi_ulong ebx;
779 abi_ulong edx;
780 abi_ulong ecx;
781 abi_ulong eax;
782 abi_ulong trapno;
783 abi_ulong err;
784 abi_ulong eip;
bellard66fb9762003-03-23 01:06:05 +0000785 uint16_t cs, __csh;
blueswir1992f48a2007-10-14 16:27:31 +0000786 abi_ulong eflags;
787 abi_ulong esp_at_signal;
bellard66fb9762003-03-23 01:06:05 +0000788 uint16_t ss, __ssh;
blueswir1992f48a2007-10-14 16:27:31 +0000789 abi_ulong fpstate; /* pointer */
790 abi_ulong oldmask;
791 abi_ulong cr2;
bellard66fb9762003-03-23 01:06:05 +0000792};
793
bellard66fb9762003-03-23 01:06:05 +0000794struct target_ucontext {
blueswir1992f48a2007-10-14 16:27:31 +0000795 abi_ulong tuc_flags;
796 abi_ulong tuc_link;
Anthony Liguoric227f092009-10-01 16:12:16 -0500797 target_stack_t tuc_stack;
bellardb8076a72005-04-07 22:20:31 +0000798 struct target_sigcontext tuc_mcontext;
Anthony Liguoric227f092009-10-01 16:12:16 -0500799 target_sigset_t tuc_sigmask; /* mask last for extensibility */
bellard66fb9762003-03-23 01:06:05 +0000800};
801
802struct sigframe
803{
blueswir1992f48a2007-10-14 16:27:31 +0000804 abi_ulong pretcode;
bellard66fb9762003-03-23 01:06:05 +0000805 int sig;
806 struct target_sigcontext sc;
807 struct target_fpstate fpstate;
blueswir1992f48a2007-10-14 16:27:31 +0000808 abi_ulong extramask[TARGET_NSIG_WORDS-1];
bellard66fb9762003-03-23 01:06:05 +0000809 char retcode[8];
810};
811
812struct rt_sigframe
813{
blueswir1992f48a2007-10-14 16:27:31 +0000814 abi_ulong pretcode;
bellard66fb9762003-03-23 01:06:05 +0000815 int sig;
blueswir1992f48a2007-10-14 16:27:31 +0000816 abi_ulong pinfo;
817 abi_ulong puc;
bellard66fb9762003-03-23 01:06:05 +0000818 struct target_siginfo info;
819 struct target_ucontext uc;
820 struct target_fpstate fpstate;
821 char retcode[8];
822};
823
824/*
825 * Set up a signal frame.
826 */
827
bellard66fb9762003-03-23 01:06:05 +0000828/* XXX: save x87 state */
Riku Voipio41ecc722014-04-23 11:01:00 +0300829static void setup_sigcontext(struct target_sigcontext *sc,
830 struct target_fpstate *fpstate, CPUX86State *env, abi_ulong mask,
831 abi_ulong fpstate_addr)
bellard66fb9762003-03-23 01:06:05 +0000832{
Andreas Färber27103422013-08-26 08:31:06 +0200833 CPUState *cs = CPU(x86_env_get_cpu(env));
Andreas Färber27103422013-08-26 08:31:06 +0200834 uint16_t magic;
bellard66fb9762003-03-23 01:06:05 +0000835
bellard579a97f2007-11-11 14:26:47 +0000836 /* already locked in setup_frame() */
Riku Voipio1d8b5122014-04-23 10:26:05 +0300837 __put_user(env->segs[R_GS].selector, (unsigned int *)&sc->gs);
838 __put_user(env->segs[R_FS].selector, (unsigned int *)&sc->fs);
839 __put_user(env->segs[R_ES].selector, (unsigned int *)&sc->es);
840 __put_user(env->segs[R_DS].selector, (unsigned int *)&sc->ds);
841 __put_user(env->regs[R_EDI], &sc->edi);
842 __put_user(env->regs[R_ESI], &sc->esi);
843 __put_user(env->regs[R_EBP], &sc->ebp);
844 __put_user(env->regs[R_ESP], &sc->esp);
845 __put_user(env->regs[R_EBX], &sc->ebx);
846 __put_user(env->regs[R_EDX], &sc->edx);
847 __put_user(env->regs[R_ECX], &sc->ecx);
848 __put_user(env->regs[R_EAX], &sc->eax);
849 __put_user(cs->exception_index, &sc->trapno);
850 __put_user(env->error_code, &sc->err);
851 __put_user(env->eip, &sc->eip);
852 __put_user(env->segs[R_CS].selector, (unsigned int *)&sc->cs);
853 __put_user(env->eflags, &sc->eflags);
854 __put_user(env->regs[R_ESP], &sc->esp_at_signal);
855 __put_user(env->segs[R_SS].selector, (unsigned int *)&sc->ss);
bellarded2dcdf2003-05-29 20:06:27 +0000856
bellard28be6232007-11-11 22:23:38 +0000857 cpu_x86_fsave(env, fpstate_addr, 1);
bellarded2dcdf2003-05-29 20:06:27 +0000858 fpstate->status = fpstate->sw;
bellard775b58d2007-11-11 16:22:17 +0000859 magic = 0xffff;
Riku Voipio1d8b5122014-04-23 10:26:05 +0300860 __put_user(magic, &fpstate->magic);
861 __put_user(fpstate_addr, &sc->fpstate);
bellarded2dcdf2003-05-29 20:06:27 +0000862
bellard66fb9762003-03-23 01:06:05 +0000863 /* non-iBCS2 extensions.. */
Riku Voipio1d8b5122014-04-23 10:26:05 +0300864 __put_user(mask, &sc->oldmask);
865 __put_user(env->cr[2], &sc->cr2);
bellard66fb9762003-03-23 01:06:05 +0000866}
867
868/*
869 * Determine which stack to use..
870 */
871
bellard579a97f2007-11-11 14:26:47 +0000872static inline abi_ulong
pbrook624f7972008-05-31 16:11:38 +0000873get_sigframe(struct target_sigaction *ka, CPUX86State *env, size_t frame_size)
bellard66fb9762003-03-23 01:06:05 +0000874{
875 unsigned long esp;
876
877 /* Default to using normal stack */
878 esp = env->regs[R_ESP];
bellard66fb9762003-03-23 01:06:05 +0000879 /* This is the X/Open sanctioned signal stack switching. */
pbrook624f7972008-05-31 16:11:38 +0000880 if (ka->sa_flags & TARGET_SA_ONSTACK) {
thsa04e1342007-09-27 13:57:58 +0000881 if (sas_ss_flags(esp) == 0)
882 esp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
883 }
bellard66fb9762003-03-23 01:06:05 +0000884
885 /* This is the legacy signal stack switching. */
ths5fafdf22007-09-16 21:08:06 +0000886 else
bellarda52c7572003-06-21 13:14:12 +0000887 if ((env->segs[R_SS].selector & 0xffff) != __USER_DS &&
pbrook624f7972008-05-31 16:11:38 +0000888 !(ka->sa_flags & TARGET_SA_RESTORER) &&
889 ka->sa_restorer) {
890 esp = (unsigned long) ka->sa_restorer;
bellarda52c7572003-06-21 13:14:12 +0000891 }
bellard579a97f2007-11-11 14:26:47 +0000892 return (esp - frame_size) & -8ul;
bellard66fb9762003-03-23 01:06:05 +0000893}
894
bellard579a97f2007-11-11 14:26:47 +0000895/* compare linux/arch/i386/kernel/signal.c:setup_frame() */
pbrook624f7972008-05-31 16:11:38 +0000896static void setup_frame(int sig, struct target_sigaction *ka,
Anthony Liguoric227f092009-10-01 16:12:16 -0500897 target_sigset_t *set, CPUX86State *env)
bellard66fb9762003-03-23 01:06:05 +0000898{
bellard579a97f2007-11-11 14:26:47 +0000899 abi_ulong frame_addr;
bellard66fb9762003-03-23 01:06:05 +0000900 struct sigframe *frame;
Riku Voipio7df2fa32014-04-23 10:34:53 +0300901 int i;
bellard66fb9762003-03-23 01:06:05 +0000902
bellard579a97f2007-11-11 14:26:47 +0000903 frame_addr = get_sigframe(ka, env, sizeof(*frame));
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +0100904 trace_user_setup_frame(env, frame_addr);
bellard66fb9762003-03-23 01:06:05 +0000905
bellard579a97f2007-11-11 14:26:47 +0000906 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
bellard66fb9762003-03-23 01:06:05 +0000907 goto give_sigsegv;
bellard579a97f2007-11-11 14:26:47 +0000908
Peter Maydellb6e2c932015-01-08 12:19:43 +0000909 __put_user(sig, &frame->sig);
bellard66fb9762003-03-23 01:06:05 +0000910
bellard28be6232007-11-11 22:23:38 +0000911 setup_sigcontext(&frame->sc, &frame->fpstate, env, set->sig[0],
912 frame_addr + offsetof(struct sigframe, fpstate));
bellard66fb9762003-03-23 01:06:05 +0000913
Riku Voipio7df2fa32014-04-23 10:34:53 +0300914 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
915 __put_user(set->sig[i], &frame->extramask[i - 1]);
916 }
bellard66fb9762003-03-23 01:06:05 +0000917
918 /* Set up to return from userspace. If provided, use a stub
919 already in userspace. */
pbrook624f7972008-05-31 16:11:38 +0000920 if (ka->sa_flags & TARGET_SA_RESTORER) {
Riku Voipio1d8b5122014-04-23 10:26:05 +0300921 __put_user(ka->sa_restorer, &frame->pretcode);
bellard66fb9762003-03-23 01:06:05 +0000922 } else {
bellard775b58d2007-11-11 16:22:17 +0000923 uint16_t val16;
bellard28be6232007-11-11 22:23:38 +0000924 abi_ulong retcode_addr;
925 retcode_addr = frame_addr + offsetof(struct sigframe, retcode);
Riku Voipio1d8b5122014-04-23 10:26:05 +0300926 __put_user(retcode_addr, &frame->pretcode);
bellard66fb9762003-03-23 01:06:05 +0000927 /* This is popl %eax ; movl $,%eax ; int $0x80 */
bellard775b58d2007-11-11 16:22:17 +0000928 val16 = 0xb858;
Riku Voipio1d8b5122014-04-23 10:26:05 +0300929 __put_user(val16, (uint16_t *)(frame->retcode+0));
930 __put_user(TARGET_NR_sigreturn, (int *)(frame->retcode+2));
bellard775b58d2007-11-11 16:22:17 +0000931 val16 = 0x80cd;
Riku Voipio1d8b5122014-04-23 10:26:05 +0300932 __put_user(val16, (uint16_t *)(frame->retcode+6));
bellard66fb9762003-03-23 01:06:05 +0000933 }
934
bellard66fb9762003-03-23 01:06:05 +0000935
936 /* Set up registers for signal handler */
bellard28be6232007-11-11 22:23:38 +0000937 env->regs[R_ESP] = frame_addr;
pbrook624f7972008-05-31 16:11:38 +0000938 env->eip = ka->_sa_handler;
bellard66fb9762003-03-23 01:06:05 +0000939
940 cpu_x86_load_seg(env, R_DS, __USER_DS);
941 cpu_x86_load_seg(env, R_ES, __USER_DS);
942 cpu_x86_load_seg(env, R_SS, __USER_DS);
943 cpu_x86_load_seg(env, R_CS, __USER_CS);
944 env->eflags &= ~TF_MASK;
945
bellard579a97f2007-11-11 14:26:47 +0000946 unlock_user_struct(frame, frame_addr, 1);
947
bellard66fb9762003-03-23 01:06:05 +0000948 return;
949
950give_sigsegv:
951 if (sig == TARGET_SIGSEGV)
pbrook624f7972008-05-31 16:11:38 +0000952 ka->_sa_handler = TARGET_SIG_DFL;
bellard66fb9762003-03-23 01:06:05 +0000953 force_sig(TARGET_SIGSEGV /* , current */);
954}
955
bellard579a97f2007-11-11 14:26:47 +0000956/* compare linux/arch/i386/kernel/signal.c:setup_rt_frame() */
pbrook624f7972008-05-31 16:11:38 +0000957static void setup_rt_frame(int sig, struct target_sigaction *ka,
Anthony Liguoric227f092009-10-01 16:12:16 -0500958 target_siginfo_t *info,
959 target_sigset_t *set, CPUX86State *env)
bellard66fb9762003-03-23 01:06:05 +0000960{
bellard28be6232007-11-11 22:23:38 +0000961 abi_ulong frame_addr, addr;
bellard66fb9762003-03-23 01:06:05 +0000962 struct rt_sigframe *frame;
Riku Voipio0188fad2014-04-23 13:34:15 +0300963 int i;
bellard66fb9762003-03-23 01:06:05 +0000964
bellard579a97f2007-11-11 14:26:47 +0000965 frame_addr = get_sigframe(ka, env, sizeof(*frame));
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +0100966 trace_user_setup_rt_frame(env, frame_addr);
bellard66fb9762003-03-23 01:06:05 +0000967
bellard579a97f2007-11-11 14:26:47 +0000968 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
bellard66fb9762003-03-23 01:06:05 +0000969 goto give_sigsegv;
bellard66fb9762003-03-23 01:06:05 +0000970
Peter Maydellb6e2c932015-01-08 12:19:43 +0000971 __put_user(sig, &frame->sig);
bellard28be6232007-11-11 22:23:38 +0000972 addr = frame_addr + offsetof(struct rt_sigframe, info);
Riku Voipio1d8b5122014-04-23 10:26:05 +0300973 __put_user(addr, &frame->pinfo);
bellard28be6232007-11-11 22:23:38 +0000974 addr = frame_addr + offsetof(struct rt_sigframe, uc);
Riku Voipio1d8b5122014-04-23 10:26:05 +0300975 __put_user(addr, &frame->puc);
Peter Maydellf6c7a052015-01-08 12:19:48 +0000976 tswap_siginfo(&frame->info, info);
bellard66fb9762003-03-23 01:06:05 +0000977
978 /* Create the ucontext. */
Riku Voipio1d8b5122014-04-23 10:26:05 +0300979 __put_user(0, &frame->uc.tuc_flags);
980 __put_user(0, &frame->uc.tuc_link);
981 __put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp);
982 __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
983 &frame->uc.tuc_stack.ss_flags);
984 __put_user(target_sigaltstack_used.ss_size,
985 &frame->uc.tuc_stack.ss_size);
Riku Voipio41ecc722014-04-23 11:01:00 +0300986 setup_sigcontext(&frame->uc.tuc_mcontext, &frame->fpstate, env,
987 set->sig[0], frame_addr + offsetof(struct rt_sigframe, fpstate));
988
Riku Voipio0188fad2014-04-23 13:34:15 +0300989 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
990 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
991 }
bellard66fb9762003-03-23 01:06:05 +0000992
993 /* Set up to return from userspace. If provided, use a stub
994 already in userspace. */
pbrook624f7972008-05-31 16:11:38 +0000995 if (ka->sa_flags & TARGET_SA_RESTORER) {
Riku Voipio1d8b5122014-04-23 10:26:05 +0300996 __put_user(ka->sa_restorer, &frame->pretcode);
bellard66fb9762003-03-23 01:06:05 +0000997 } else {
bellard775b58d2007-11-11 16:22:17 +0000998 uint16_t val16;
bellard28be6232007-11-11 22:23:38 +0000999 addr = frame_addr + offsetof(struct rt_sigframe, retcode);
Riku Voipio1d8b5122014-04-23 10:26:05 +03001000 __put_user(addr, &frame->pretcode);
bellard66fb9762003-03-23 01:06:05 +00001001 /* This is movl $,%eax ; int $0x80 */
Riku Voipio1d8b5122014-04-23 10:26:05 +03001002 __put_user(0xb8, (char *)(frame->retcode+0));
1003 __put_user(TARGET_NR_rt_sigreturn, (int *)(frame->retcode+1));
bellard775b58d2007-11-11 16:22:17 +00001004 val16 = 0x80cd;
Riku Voipio1d8b5122014-04-23 10:26:05 +03001005 __put_user(val16, (uint16_t *)(frame->retcode+5));
bellard66fb9762003-03-23 01:06:05 +00001006 }
1007
bellard66fb9762003-03-23 01:06:05 +00001008 /* Set up registers for signal handler */
bellard28be6232007-11-11 22:23:38 +00001009 env->regs[R_ESP] = frame_addr;
pbrook624f7972008-05-31 16:11:38 +00001010 env->eip = ka->_sa_handler;
bellard66fb9762003-03-23 01:06:05 +00001011
1012 cpu_x86_load_seg(env, R_DS, __USER_DS);
1013 cpu_x86_load_seg(env, R_ES, __USER_DS);
1014 cpu_x86_load_seg(env, R_SS, __USER_DS);
1015 cpu_x86_load_seg(env, R_CS, __USER_CS);
1016 env->eflags &= ~TF_MASK;
1017
bellard579a97f2007-11-11 14:26:47 +00001018 unlock_user_struct(frame, frame_addr, 1);
1019
bellard66fb9762003-03-23 01:06:05 +00001020 return;
1021
1022give_sigsegv:
1023 if (sig == TARGET_SIGSEGV)
pbrook624f7972008-05-31 16:11:38 +00001024 ka->_sa_handler = TARGET_SIG_DFL;
bellard66fb9762003-03-23 01:06:05 +00001025 force_sig(TARGET_SIGSEGV /* , current */);
1026}
1027
1028static int
1029restore_sigcontext(CPUX86State *env, struct target_sigcontext *sc, int *peax)
1030{
1031 unsigned int err = 0;
bellard28be6232007-11-11 22:23:38 +00001032 abi_ulong fpstate_addr;
1033 unsigned int tmpflags;
bellard66fb9762003-03-23 01:06:05 +00001034
bellard28be6232007-11-11 22:23:38 +00001035 cpu_x86_load_seg(env, R_GS, tswap16(sc->gs));
1036 cpu_x86_load_seg(env, R_FS, tswap16(sc->fs));
1037 cpu_x86_load_seg(env, R_ES, tswap16(sc->es));
1038 cpu_x86_load_seg(env, R_DS, tswap16(sc->ds));
bellard66fb9762003-03-23 01:06:05 +00001039
bellard28be6232007-11-11 22:23:38 +00001040 env->regs[R_EDI] = tswapl(sc->edi);
1041 env->regs[R_ESI] = tswapl(sc->esi);
1042 env->regs[R_EBP] = tswapl(sc->ebp);
1043 env->regs[R_ESP] = tswapl(sc->esp);
1044 env->regs[R_EBX] = tswapl(sc->ebx);
1045 env->regs[R_EDX] = tswapl(sc->edx);
1046 env->regs[R_ECX] = tswapl(sc->ecx);
1047 env->eip = tswapl(sc->eip);
bellard66fb9762003-03-23 01:06:05 +00001048
Mike McCormack9a826d72011-06-01 15:14:37 +09001049 cpu_x86_load_seg(env, R_CS, lduw_p(&sc->cs) | 3);
1050 cpu_x86_load_seg(env, R_SS, lduw_p(&sc->ss) | 3);
ths5fafdf22007-09-16 21:08:06 +00001051
bellard28be6232007-11-11 22:23:38 +00001052 tmpflags = tswapl(sc->eflags);
1053 env->eflags = (env->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);
1054 // regs->orig_eax = -1; /* disable syscall checks */
1055
1056 fpstate_addr = tswapl(sc->fpstate);
1057 if (fpstate_addr != 0) {
1058 if (!access_ok(VERIFY_READ, fpstate_addr,
1059 sizeof(struct target_fpstate)))
1060 goto badframe;
1061 cpu_x86_frstor(env, fpstate_addr, 1);
bellard66fb9762003-03-23 01:06:05 +00001062 }
1063
bellard28be6232007-11-11 22:23:38 +00001064 *peax = tswapl(sc->eax);
bellard66fb9762003-03-23 01:06:05 +00001065 return err;
bellard66fb9762003-03-23 01:06:05 +00001066badframe:
1067 return 1;
bellard66fb9762003-03-23 01:06:05 +00001068}
1069
1070long do_sigreturn(CPUX86State *env)
1071{
bellard579a97f2007-11-11 14:26:47 +00001072 struct sigframe *frame;
1073 abi_ulong frame_addr = env->regs[R_ESP] - 8;
Anthony Liguoric227f092009-10-01 16:12:16 -05001074 target_sigset_t target_set;
bellard66fb9762003-03-23 01:06:05 +00001075 sigset_t set;
1076 int eax, i;
1077
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01001078 trace_user_do_sigreturn(env, frame_addr);
bellard579a97f2007-11-11 14:26:47 +00001079 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1080 goto badframe;
bellard66fb9762003-03-23 01:06:05 +00001081 /* set blocked signals */
Riku Voipiof5f601a2014-04-23 13:00:17 +03001082 __get_user(target_set.sig[0], &frame->sc.oldmask);
bellard92319442004-06-19 16:58:13 +00001083 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
Riku Voipiof5f601a2014-04-23 13:00:17 +03001084 __get_user(target_set.sig[i], &frame->extramask[i - 1]);
bellard92319442004-06-19 16:58:13 +00001085 }
bellard66fb9762003-03-23 01:06:05 +00001086
bellard92319442004-06-19 16:58:13 +00001087 target_to_host_sigset_internal(&set, &target_set);
Alex Barcelo1c275922014-03-14 14:36:55 +00001088 do_sigprocmask(SIG_SETMASK, &set, NULL);
ths3b46e622007-09-17 08:09:54 +00001089
bellard66fb9762003-03-23 01:06:05 +00001090 /* restore registers */
1091 if (restore_sigcontext(env, &frame->sc, &eax))
1092 goto badframe;
bellard579a97f2007-11-11 14:26:47 +00001093 unlock_user_struct(frame, frame_addr, 0);
bellard66fb9762003-03-23 01:06:05 +00001094 return eax;
1095
1096badframe:
bellard579a97f2007-11-11 14:26:47 +00001097 unlock_user_struct(frame, frame_addr, 0);
bellard66fb9762003-03-23 01:06:05 +00001098 force_sig(TARGET_SIGSEGV);
1099 return 0;
1100}
1101
1102long do_rt_sigreturn(CPUX86State *env)
1103{
bellard28be6232007-11-11 22:23:38 +00001104 abi_ulong frame_addr;
1105 struct rt_sigframe *frame;
bellard66fb9762003-03-23 01:06:05 +00001106 sigset_t set;
bellard66fb9762003-03-23 01:06:05 +00001107 int eax;
1108
bellard28be6232007-11-11 22:23:38 +00001109 frame_addr = env->regs[R_ESP] - 4;
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01001110 trace_user_do_rt_sigreturn(env, frame_addr);
bellard28be6232007-11-11 22:23:38 +00001111 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1112 goto badframe;
bellardb8076a72005-04-07 22:20:31 +00001113 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
Alex Barcelo1c275922014-03-14 14:36:55 +00001114 do_sigprocmask(SIG_SETMASK, &set, NULL);
ths5fafdf22007-09-16 21:08:06 +00001115
bellardb8076a72005-04-07 22:20:31 +00001116 if (restore_sigcontext(env, &frame->uc.tuc_mcontext, &eax))
bellard66fb9762003-03-23 01:06:05 +00001117 goto badframe;
1118
bellard28be6232007-11-11 22:23:38 +00001119 if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe, uc.tuc_stack), 0,
1120 get_sp_from_cpustate(env)) == -EFAULT)
bellard66fb9762003-03-23 01:06:05 +00001121 goto badframe;
thsa04e1342007-09-27 13:57:58 +00001122
bellard28be6232007-11-11 22:23:38 +00001123 unlock_user_struct(frame, frame_addr, 0);
bellard66fb9762003-03-23 01:06:05 +00001124 return eax;
1125
1126badframe:
bellard28be6232007-11-11 22:23:38 +00001127 unlock_user_struct(frame, frame_addr, 0);
1128 force_sig(TARGET_SIGSEGV);
bellard66fb9762003-03-23 01:06:05 +00001129 return 0;
1130}
1131
Andreas Schwab1744aea2013-09-03 20:12:16 +01001132#elif defined(TARGET_AARCH64)
1133
1134struct target_sigcontext {
1135 uint64_t fault_address;
1136 /* AArch64 registers */
1137 uint64_t regs[31];
1138 uint64_t sp;
1139 uint64_t pc;
1140 uint64_t pstate;
1141 /* 4K reserved for FP/SIMD state and future expansion */
1142 char __reserved[4096] __attribute__((__aligned__(16)));
1143};
1144
1145struct target_ucontext {
1146 abi_ulong tuc_flags;
1147 abi_ulong tuc_link;
1148 target_stack_t tuc_stack;
1149 target_sigset_t tuc_sigmask;
1150 /* glibc uses a 1024-bit sigset_t */
1151 char __unused[1024 / 8 - sizeof(target_sigset_t)];
1152 /* last for future expansion */
1153 struct target_sigcontext tuc_mcontext;
1154};
1155
1156/*
1157 * Header to be used at the beginning of structures extending the user
1158 * context. Such structures must be placed after the rt_sigframe on the stack
1159 * and be 16-byte aligned. The last structure must be a dummy one with the
1160 * magic and size set to 0.
1161 */
1162struct target_aarch64_ctx {
1163 uint32_t magic;
1164 uint32_t size;
1165};
1166
1167#define TARGET_FPSIMD_MAGIC 0x46508001
1168
1169struct target_fpsimd_context {
1170 struct target_aarch64_ctx head;
1171 uint32_t fpsr;
1172 uint32_t fpcr;
1173 uint64_t vregs[32 * 2]; /* really uint128_t vregs[32] */
1174};
1175
1176/*
1177 * Auxiliary context saved in the sigcontext.__reserved array. Not exported to
1178 * user space as it will change with the addition of new context. User space
1179 * should check the magic/size information.
1180 */
1181struct target_aux_context {
1182 struct target_fpsimd_context fpsimd;
1183 /* additional context to be added before "end" */
1184 struct target_aarch64_ctx end;
1185};
1186
1187struct target_rt_sigframe {
1188 struct target_siginfo info;
1189 struct target_ucontext uc;
1190 uint64_t fp;
1191 uint64_t lr;
1192 uint32_t tramp[2];
1193};
1194
1195static int target_setup_sigframe(struct target_rt_sigframe *sf,
1196 CPUARMState *env, target_sigset_t *set)
1197{
1198 int i;
1199 struct target_aux_context *aux =
1200 (struct target_aux_context *)sf->uc.tuc_mcontext.__reserved;
1201
1202 /* set up the stack frame for unwinding */
1203 __put_user(env->xregs[29], &sf->fp);
1204 __put_user(env->xregs[30], &sf->lr);
1205
1206 for (i = 0; i < 31; i++) {
1207 __put_user(env->xregs[i], &sf->uc.tuc_mcontext.regs[i]);
1208 }
1209 __put_user(env->xregs[31], &sf->uc.tuc_mcontext.sp);
1210 __put_user(env->pc, &sf->uc.tuc_mcontext.pc);
Peter Maydelld3563122013-12-17 19:42:30 +00001211 __put_user(pstate_read(env), &sf->uc.tuc_mcontext.pstate);
Andreas Schwab1744aea2013-09-03 20:12:16 +01001212
Peter Maydell7af03922014-05-01 18:36:17 +01001213 __put_user(env->exception.vaddress, &sf->uc.tuc_mcontext.fault_address);
Andreas Schwab1744aea2013-09-03 20:12:16 +01001214
1215 for (i = 0; i < TARGET_NSIG_WORDS; i++) {
1216 __put_user(set->sig[i], &sf->uc.tuc_sigmask.sig[i]);
1217 }
1218
1219 for (i = 0; i < 32; i++) {
1220#ifdef TARGET_WORDS_BIGENDIAN
1221 __put_user(env->vfp.regs[i * 2], &aux->fpsimd.vregs[i * 2 + 1]);
1222 __put_user(env->vfp.regs[i * 2 + 1], &aux->fpsimd.vregs[i * 2]);
1223#else
1224 __put_user(env->vfp.regs[i * 2], &aux->fpsimd.vregs[i * 2]);
1225 __put_user(env->vfp.regs[i * 2 + 1], &aux->fpsimd.vregs[i * 2 + 1]);
1226#endif
1227 }
Will Newtone0ee1382014-01-04 22:15:48 +00001228 __put_user(vfp_get_fpsr(env), &aux->fpsimd.fpsr);
1229 __put_user(vfp_get_fpcr(env), &aux->fpsimd.fpcr);
Andreas Schwab1744aea2013-09-03 20:12:16 +01001230 __put_user(TARGET_FPSIMD_MAGIC, &aux->fpsimd.head.magic);
1231 __put_user(sizeof(struct target_fpsimd_context),
1232 &aux->fpsimd.head.size);
1233
1234 /* set the "end" magic */
1235 __put_user(0, &aux->end.magic);
1236 __put_user(0, &aux->end.size);
1237
1238 return 0;
1239}
1240
1241static int target_restore_sigframe(CPUARMState *env,
1242 struct target_rt_sigframe *sf)
1243{
1244 sigset_t set;
1245 int i;
1246 struct target_aux_context *aux =
1247 (struct target_aux_context *)sf->uc.tuc_mcontext.__reserved;
Will Newtone0ee1382014-01-04 22:15:48 +00001248 uint32_t magic, size, fpsr, fpcr;
Peter Maydelld3563122013-12-17 19:42:30 +00001249 uint64_t pstate;
Andreas Schwab1744aea2013-09-03 20:12:16 +01001250
1251 target_to_host_sigset(&set, &sf->uc.tuc_sigmask);
Alex Barcelo1c275922014-03-14 14:36:55 +00001252 do_sigprocmask(SIG_SETMASK, &set, NULL);
Andreas Schwab1744aea2013-09-03 20:12:16 +01001253
1254 for (i = 0; i < 31; i++) {
1255 __get_user(env->xregs[i], &sf->uc.tuc_mcontext.regs[i]);
1256 }
1257
1258 __get_user(env->xregs[31], &sf->uc.tuc_mcontext.sp);
1259 __get_user(env->pc, &sf->uc.tuc_mcontext.pc);
Peter Maydelld3563122013-12-17 19:42:30 +00001260 __get_user(pstate, &sf->uc.tuc_mcontext.pstate);
1261 pstate_write(env, pstate);
Andreas Schwab1744aea2013-09-03 20:12:16 +01001262
1263 __get_user(magic, &aux->fpsimd.head.magic);
1264 __get_user(size, &aux->fpsimd.head.size);
1265
1266 if (magic != TARGET_FPSIMD_MAGIC
1267 || size != sizeof(struct target_fpsimd_context)) {
1268 return 1;
1269 }
1270
Peter Maydell4cf23482014-03-02 19:36:38 +00001271 for (i = 0; i < 32; i++) {
1272#ifdef TARGET_WORDS_BIGENDIAN
1273 __get_user(env->vfp.regs[i * 2], &aux->fpsimd.vregs[i * 2 + 1]);
1274 __get_user(env->vfp.regs[i * 2 + 1], &aux->fpsimd.vregs[i * 2]);
1275#else
1276 __get_user(env->vfp.regs[i * 2], &aux->fpsimd.vregs[i * 2]);
1277 __get_user(env->vfp.regs[i * 2 + 1], &aux->fpsimd.vregs[i * 2 + 1]);
1278#endif
Andreas Schwab1744aea2013-09-03 20:12:16 +01001279 }
Will Newtone0ee1382014-01-04 22:15:48 +00001280 __get_user(fpsr, &aux->fpsimd.fpsr);
1281 vfp_set_fpsr(env, fpsr);
1282 __get_user(fpcr, &aux->fpsimd.fpcr);
1283 vfp_set_fpcr(env, fpcr);
Andreas Schwab1744aea2013-09-03 20:12:16 +01001284
1285 return 0;
1286}
1287
1288static abi_ulong get_sigframe(struct target_sigaction *ka, CPUARMState *env)
1289{
1290 abi_ulong sp;
1291
1292 sp = env->xregs[31];
1293
1294 /*
1295 * This is the X/Open sanctioned signal stack switching.
1296 */
Riku Voipiob545f632014-07-15 17:01:55 +03001297 if ((ka->sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp)) {
Andreas Schwab1744aea2013-09-03 20:12:16 +01001298 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
1299 }
1300
1301 sp = (sp - sizeof(struct target_rt_sigframe)) & ~15;
1302
1303 return sp;
1304}
1305
1306static void target_setup_frame(int usig, struct target_sigaction *ka,
1307 target_siginfo_t *info, target_sigset_t *set,
1308 CPUARMState *env)
1309{
1310 struct target_rt_sigframe *frame;
Michael Matz8a3ae912014-03-02 19:36:39 +00001311 abi_ulong frame_addr, return_addr;
Andreas Schwab1744aea2013-09-03 20:12:16 +01001312
1313 frame_addr = get_sigframe(ka, env);
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01001314 trace_user_setup_frame(env, frame_addr);
Andreas Schwab1744aea2013-09-03 20:12:16 +01001315 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
1316 goto give_sigsegv;
1317 }
1318
1319 __put_user(0, &frame->uc.tuc_flags);
1320 __put_user(0, &frame->uc.tuc_link);
1321
1322 __put_user(target_sigaltstack_used.ss_sp,
1323 &frame->uc.tuc_stack.ss_sp);
1324 __put_user(sas_ss_flags(env->xregs[31]),
1325 &frame->uc.tuc_stack.ss_flags);
1326 __put_user(target_sigaltstack_used.ss_size,
1327 &frame->uc.tuc_stack.ss_size);
1328 target_setup_sigframe(frame, env, set);
Michael Matz8a3ae912014-03-02 19:36:39 +00001329 if (ka->sa_flags & TARGET_SA_RESTORER) {
1330 return_addr = ka->sa_restorer;
1331 } else {
1332 /* mov x8,#__NR_rt_sigreturn; svc #0 */
1333 __put_user(0xd2801168, &frame->tramp[0]);
1334 __put_user(0xd4000001, &frame->tramp[1]);
1335 return_addr = frame_addr + offsetof(struct target_rt_sigframe, tramp);
1336 }
Andreas Schwab1744aea2013-09-03 20:12:16 +01001337 env->xregs[0] = usig;
1338 env->xregs[31] = frame_addr;
1339 env->xregs[29] = env->xregs[31] + offsetof(struct target_rt_sigframe, fp);
1340 env->pc = ka->_sa_handler;
Michael Matz8a3ae912014-03-02 19:36:39 +00001341 env->xregs[30] = return_addr;
Andreas Schwab1744aea2013-09-03 20:12:16 +01001342 if (info) {
Peter Maydellf6c7a052015-01-08 12:19:48 +00001343 tswap_siginfo(&frame->info, info);
Andreas Schwab1744aea2013-09-03 20:12:16 +01001344 env->xregs[1] = frame_addr + offsetof(struct target_rt_sigframe, info);
1345 env->xregs[2] = frame_addr + offsetof(struct target_rt_sigframe, uc);
1346 }
1347
1348 unlock_user_struct(frame, frame_addr, 1);
1349 return;
1350
1351 give_sigsegv:
1352 unlock_user_struct(frame, frame_addr, 1);
1353 force_sig(TARGET_SIGSEGV);
1354}
1355
1356static void setup_rt_frame(int sig, struct target_sigaction *ka,
1357 target_siginfo_t *info, target_sigset_t *set,
1358 CPUARMState *env)
1359{
1360 target_setup_frame(sig, ka, info, set, env);
1361}
1362
1363static void setup_frame(int sig, struct target_sigaction *ka,
1364 target_sigset_t *set, CPUARMState *env)
1365{
1366 target_setup_frame(sig, ka, 0, set, env);
1367}
1368
1369long do_rt_sigreturn(CPUARMState *env)
1370{
Peter Maydell7f72cd22014-03-12 13:06:00 +00001371 struct target_rt_sigframe *frame = NULL;
Andreas Schwab1744aea2013-09-03 20:12:16 +01001372 abi_ulong frame_addr = env->xregs[31];
1373
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01001374 trace_user_do_rt_sigreturn(env, frame_addr);
Andreas Schwab1744aea2013-09-03 20:12:16 +01001375 if (frame_addr & 15) {
1376 goto badframe;
1377 }
1378
1379 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
1380 goto badframe;
1381 }
1382
1383 if (target_restore_sigframe(env, frame)) {
1384 goto badframe;
1385 }
1386
1387 if (do_sigaltstack(frame_addr +
1388 offsetof(struct target_rt_sigframe, uc.tuc_stack),
1389 0, get_sp_from_cpustate(env)) == -EFAULT) {
1390 goto badframe;
1391 }
1392
1393 unlock_user_struct(frame, frame_addr, 0);
1394 return env->xregs[0];
1395
1396 badframe:
1397 unlock_user_struct(frame, frame_addr, 0);
1398 force_sig(TARGET_SIGSEGV);
1399 return 0;
1400}
1401
1402long do_sigreturn(CPUARMState *env)
1403{
1404 return do_rt_sigreturn(env);
1405}
1406
bellard43fff232003-07-09 19:31:39 +00001407#elif defined(TARGET_ARM)
1408
1409struct target_sigcontext {
blueswir1992f48a2007-10-14 16:27:31 +00001410 abi_ulong trap_no;
1411 abi_ulong error_code;
1412 abi_ulong oldmask;
1413 abi_ulong arm_r0;
1414 abi_ulong arm_r1;
1415 abi_ulong arm_r2;
1416 abi_ulong arm_r3;
1417 abi_ulong arm_r4;
1418 abi_ulong arm_r5;
1419 abi_ulong arm_r6;
1420 abi_ulong arm_r7;
1421 abi_ulong arm_r8;
1422 abi_ulong arm_r9;
1423 abi_ulong arm_r10;
1424 abi_ulong arm_fp;
1425 abi_ulong arm_ip;
1426 abi_ulong arm_sp;
1427 abi_ulong arm_lr;
1428 abi_ulong arm_pc;
1429 abi_ulong arm_cpsr;
1430 abi_ulong fault_address;
bellard43fff232003-07-09 19:31:39 +00001431};
1432
pbrooka745ec62008-05-06 15:36:17 +00001433struct target_ucontext_v1 {
blueswir1992f48a2007-10-14 16:27:31 +00001434 abi_ulong tuc_flags;
1435 abi_ulong tuc_link;
Anthony Liguoric227f092009-10-01 16:12:16 -05001436 target_stack_t tuc_stack;
bellardb8076a72005-04-07 22:20:31 +00001437 struct target_sigcontext tuc_mcontext;
Anthony Liguoric227f092009-10-01 16:12:16 -05001438 target_sigset_t tuc_sigmask; /* mask last for extensibility */
bellard43fff232003-07-09 19:31:39 +00001439};
1440
pbrooka745ec62008-05-06 15:36:17 +00001441struct target_ucontext_v2 {
1442 abi_ulong tuc_flags;
1443 abi_ulong tuc_link;
Anthony Liguoric227f092009-10-01 16:12:16 -05001444 target_stack_t tuc_stack;
pbrooka745ec62008-05-06 15:36:17 +00001445 struct target_sigcontext tuc_mcontext;
Anthony Liguoric227f092009-10-01 16:12:16 -05001446 target_sigset_t tuc_sigmask; /* mask last for extensibility */
Peter Maydell5f0b7c82010-11-24 15:20:03 +00001447 char __unused[128 - sizeof(target_sigset_t)];
pbrooka745ec62008-05-06 15:36:17 +00001448 abi_ulong tuc_regspace[128] __attribute__((__aligned__(8)));
1449};
1450
Peter Maydell0d871bd2010-11-24 15:20:05 +00001451struct target_user_vfp {
1452 uint64_t fpregs[32];
1453 abi_ulong fpscr;
1454};
1455
1456struct target_user_vfp_exc {
1457 abi_ulong fpexc;
1458 abi_ulong fpinst;
1459 abi_ulong fpinst2;
1460};
1461
1462struct target_vfp_sigframe {
1463 abi_ulong magic;
1464 abi_ulong size;
1465 struct target_user_vfp ufp;
1466 struct target_user_vfp_exc ufp_exc;
1467} __attribute__((__aligned__(8)));
1468
Peter Maydell08e11252010-11-24 15:20:07 +00001469struct target_iwmmxt_sigframe {
1470 abi_ulong magic;
1471 abi_ulong size;
1472 uint64_t regs[16];
1473 /* Note that not all the coprocessor control registers are stored here */
1474 uint32_t wcssf;
1475 uint32_t wcasf;
1476 uint32_t wcgr0;
1477 uint32_t wcgr1;
1478 uint32_t wcgr2;
1479 uint32_t wcgr3;
1480} __attribute__((__aligned__(8)));
1481
Peter Maydell0d871bd2010-11-24 15:20:05 +00001482#define TARGET_VFP_MAGIC 0x56465001
Peter Maydell08e11252010-11-24 15:20:07 +00001483#define TARGET_IWMMXT_MAGIC 0x12ef842a
Peter Maydell0d871bd2010-11-24 15:20:05 +00001484
pbrooka8c33202008-05-07 23:22:46 +00001485struct sigframe_v1
bellard43fff232003-07-09 19:31:39 +00001486{
1487 struct target_sigcontext sc;
blueswir1992f48a2007-10-14 16:27:31 +00001488 abi_ulong extramask[TARGET_NSIG_WORDS-1];
1489 abi_ulong retcode;
bellard43fff232003-07-09 19:31:39 +00001490};
1491
pbrooka8c33202008-05-07 23:22:46 +00001492struct sigframe_v2
1493{
1494 struct target_ucontext_v2 uc;
1495 abi_ulong retcode;
1496};
1497
pbrooka745ec62008-05-06 15:36:17 +00001498struct rt_sigframe_v1
bellard43fff232003-07-09 19:31:39 +00001499{
bellardf8b0aa22007-11-11 23:03:42 +00001500 abi_ulong pinfo;
1501 abi_ulong puc;
bellard43fff232003-07-09 19:31:39 +00001502 struct target_siginfo info;
pbrooka745ec62008-05-06 15:36:17 +00001503 struct target_ucontext_v1 uc;
1504 abi_ulong retcode;
1505};
1506
1507struct rt_sigframe_v2
1508{
1509 struct target_siginfo info;
1510 struct target_ucontext_v2 uc;
blueswir1992f48a2007-10-14 16:27:31 +00001511 abi_ulong retcode;
bellard43fff232003-07-09 19:31:39 +00001512};
1513
1514#define TARGET_CONFIG_CPU_32 1
1515
1516/*
1517 * For ARM syscalls, we encode the syscall number into the instruction.
1518 */
1519#define SWI_SYS_SIGRETURN (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE))
1520#define SWI_SYS_RT_SIGRETURN (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE))
1521
1522/*
1523 * For Thumb syscalls, we pass the syscall number via r7. We therefore
1524 * need two 16-bit instructions.
1525 */
1526#define SWI_THUMB_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn))
1527#define SWI_THUMB_RT_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn))
1528
blueswir1992f48a2007-10-14 16:27:31 +00001529static const abi_ulong retcodes[4] = {
bellard43fff232003-07-09 19:31:39 +00001530 SWI_SYS_SIGRETURN, SWI_THUMB_SIGRETURN,
1531 SWI_SYS_RT_SIGRETURN, SWI_THUMB_RT_SIGRETURN
1532};
1533
1534
Andreas Färber05390242012-02-25 03:37:53 +01001535static inline int valid_user_regs(CPUARMState *regs)
bellard43fff232003-07-09 19:31:39 +00001536{
1537 return 1;
1538}
1539
pbrooka8c33202008-05-07 23:22:46 +00001540static void
bellard43fff232003-07-09 19:31:39 +00001541setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
Andreas Färber05390242012-02-25 03:37:53 +01001542 CPUARMState *env, abi_ulong mask)
bellard43fff232003-07-09 19:31:39 +00001543{
pbrooka8c33202008-05-07 23:22:46 +00001544 __put_user(env->regs[0], &sc->arm_r0);
1545 __put_user(env->regs[1], &sc->arm_r1);
1546 __put_user(env->regs[2], &sc->arm_r2);
1547 __put_user(env->regs[3], &sc->arm_r3);
1548 __put_user(env->regs[4], &sc->arm_r4);
1549 __put_user(env->regs[5], &sc->arm_r5);
1550 __put_user(env->regs[6], &sc->arm_r6);
1551 __put_user(env->regs[7], &sc->arm_r7);
1552 __put_user(env->regs[8], &sc->arm_r8);
1553 __put_user(env->regs[9], &sc->arm_r9);
1554 __put_user(env->regs[10], &sc->arm_r10);
1555 __put_user(env->regs[11], &sc->arm_fp);
1556 __put_user(env->regs[12], &sc->arm_ip);
1557 __put_user(env->regs[13], &sc->arm_sp);
1558 __put_user(env->regs[14], &sc->arm_lr);
1559 __put_user(env->regs[15], &sc->arm_pc);
bellard43fff232003-07-09 19:31:39 +00001560#ifdef TARGET_CONFIG_CPU_32
pbrooka8c33202008-05-07 23:22:46 +00001561 __put_user(cpsr_read(env), &sc->arm_cpsr);
bellard43fff232003-07-09 19:31:39 +00001562#endif
1563
pbrooka8c33202008-05-07 23:22:46 +00001564 __put_user(/* current->thread.trap_no */ 0, &sc->trap_no);
1565 __put_user(/* current->thread.error_code */ 0, &sc->error_code);
1566 __put_user(/* current->thread.address */ 0, &sc->fault_address);
1567 __put_user(mask, &sc->oldmask);
bellard43fff232003-07-09 19:31:39 +00001568}
1569
bellard579a97f2007-11-11 14:26:47 +00001570static inline abi_ulong
Andreas Färber05390242012-02-25 03:37:53 +01001571get_sigframe(struct target_sigaction *ka, CPUARMState *regs, int framesize)
bellard43fff232003-07-09 19:31:39 +00001572{
1573 unsigned long sp = regs->regs[13];
1574
bellard43fff232003-07-09 19:31:39 +00001575 /*
1576 * This is the X/Open sanctioned signal stack switching.
1577 */
pbrook624f7972008-05-31 16:11:38 +00001578 if ((ka->sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp))
thsa04e1342007-09-27 13:57:58 +00001579 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
bellard43fff232003-07-09 19:31:39 +00001580 /*
1581 * ATPCS B01 mandates 8-byte alignment
1582 */
bellard579a97f2007-11-11 14:26:47 +00001583 return (sp - framesize) & ~7;
bellard43fff232003-07-09 19:31:39 +00001584}
1585
Riku Voipio0188fad2014-04-23 13:34:15 +03001586static void
Andreas Färber05390242012-02-25 03:37:53 +01001587setup_return(CPUARMState *env, struct target_sigaction *ka,
bellardf8b0aa22007-11-11 23:03:42 +00001588 abi_ulong *rc, abi_ulong frame_addr, int usig, abi_ulong rc_addr)
bellard43fff232003-07-09 19:31:39 +00001589{
pbrook624f7972008-05-31 16:11:38 +00001590 abi_ulong handler = ka->_sa_handler;
blueswir1992f48a2007-10-14 16:27:31 +00001591 abi_ulong retcode;
pbrook75b680e2008-03-21 16:07:30 +00001592 int thumb = handler & 1;
Peter Maydell964413d2011-01-14 20:39:19 +01001593 uint32_t cpsr = cpsr_read(env);
1594
1595 cpsr &= ~CPSR_IT;
1596 if (thumb) {
1597 cpsr |= CPSR_T;
1598 } else {
1599 cpsr &= ~CPSR_T;
1600 }
bellard43fff232003-07-09 19:31:39 +00001601
pbrook624f7972008-05-31 16:11:38 +00001602 if (ka->sa_flags & TARGET_SA_RESTORER) {
1603 retcode = ka->sa_restorer;
bellard43fff232003-07-09 19:31:39 +00001604 } else {
1605 unsigned int idx = thumb;
1606
pbrook624f7972008-05-31 16:11:38 +00001607 if (ka->sa_flags & TARGET_SA_SIGINFO)
bellard43fff232003-07-09 19:31:39 +00001608 idx += 2;
1609
Riku Voipio0188fad2014-04-23 13:34:15 +03001610 __put_user(retcodes[idx], rc);
Stefan Weilca8a2772011-10-03 22:43:19 +02001611
bellardf8b0aa22007-11-11 23:03:42 +00001612 retcode = rc_addr + thumb;
bellard43fff232003-07-09 19:31:39 +00001613 }
1614
1615 env->regs[0] = usig;
bellardf8b0aa22007-11-11 23:03:42 +00001616 env->regs[13] = frame_addr;
bellard43fff232003-07-09 19:31:39 +00001617 env->regs[14] = retcode;
1618 env->regs[15] = handler & (thumb ? ~1 : ~3);
Peter Maydell964413d2011-01-14 20:39:19 +01001619 cpsr_write(env, cpsr, 0xffffffff);
bellard43fff232003-07-09 19:31:39 +00001620}
1621
Andreas Färber05390242012-02-25 03:37:53 +01001622static abi_ulong *setup_sigframe_v2_vfp(abi_ulong *regspace, CPUARMState *env)
Peter Maydell0d871bd2010-11-24 15:20:05 +00001623{
1624 int i;
1625 struct target_vfp_sigframe *vfpframe;
1626 vfpframe = (struct target_vfp_sigframe *)regspace;
1627 __put_user(TARGET_VFP_MAGIC, &vfpframe->magic);
1628 __put_user(sizeof(*vfpframe), &vfpframe->size);
1629 for (i = 0; i < 32; i++) {
Peter Maydell005e1a02011-02-10 13:59:35 +00001630 __put_user(float64_val(env->vfp.regs[i]), &vfpframe->ufp.fpregs[i]);
Peter Maydell0d871bd2010-11-24 15:20:05 +00001631 }
1632 __put_user(vfp_get_fpscr(env), &vfpframe->ufp.fpscr);
1633 __put_user(env->vfp.xregs[ARM_VFP_FPEXC], &vfpframe->ufp_exc.fpexc);
1634 __put_user(env->vfp.xregs[ARM_VFP_FPINST], &vfpframe->ufp_exc.fpinst);
1635 __put_user(env->vfp.xregs[ARM_VFP_FPINST2], &vfpframe->ufp_exc.fpinst2);
1636 return (abi_ulong*)(vfpframe+1);
1637}
1638
Andreas Färber05390242012-02-25 03:37:53 +01001639static abi_ulong *setup_sigframe_v2_iwmmxt(abi_ulong *regspace,
1640 CPUARMState *env)
Peter Maydell08e11252010-11-24 15:20:07 +00001641{
1642 int i;
1643 struct target_iwmmxt_sigframe *iwmmxtframe;
1644 iwmmxtframe = (struct target_iwmmxt_sigframe *)regspace;
1645 __put_user(TARGET_IWMMXT_MAGIC, &iwmmxtframe->magic);
1646 __put_user(sizeof(*iwmmxtframe), &iwmmxtframe->size);
1647 for (i = 0; i < 16; i++) {
1648 __put_user(env->iwmmxt.regs[i], &iwmmxtframe->regs[i]);
1649 }
1650 __put_user(env->vfp.xregs[ARM_IWMMXT_wCSSF], &iwmmxtframe->wcssf);
1651 __put_user(env->vfp.xregs[ARM_IWMMXT_wCASF], &iwmmxtframe->wcssf);
1652 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR0], &iwmmxtframe->wcgr0);
1653 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR1], &iwmmxtframe->wcgr1);
1654 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR2], &iwmmxtframe->wcgr2);
1655 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR3], &iwmmxtframe->wcgr3);
1656 return (abi_ulong*)(iwmmxtframe+1);
1657}
1658
pbrooka8c33202008-05-07 23:22:46 +00001659static void setup_sigframe_v2(struct target_ucontext_v2 *uc,
Andreas Färber05390242012-02-25 03:37:53 +01001660 target_sigset_t *set, CPUARMState *env)
bellard43fff232003-07-09 19:31:39 +00001661{
pbrooka8c33202008-05-07 23:22:46 +00001662 struct target_sigaltstack stack;
1663 int i;
Peter Maydell0d871bd2010-11-24 15:20:05 +00001664 abi_ulong *regspace;
pbrooka8c33202008-05-07 23:22:46 +00001665
1666 /* Clear all the bits of the ucontext we don't use. */
1667 memset(uc, 0, offsetof(struct target_ucontext_v2, tuc_mcontext));
1668
1669 memset(&stack, 0, sizeof(stack));
1670 __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp);
1671 __put_user(target_sigaltstack_used.ss_size, &stack.ss_size);
1672 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags);
1673 memcpy(&uc->tuc_stack, &stack, sizeof(stack));
1674
1675 setup_sigcontext(&uc->tuc_mcontext, env, set->sig[0]);
Peter Maydell0d871bd2010-11-24 15:20:05 +00001676 /* Save coprocessor signal frame. */
1677 regspace = uc->tuc_regspace;
1678 if (arm_feature(env, ARM_FEATURE_VFP)) {
1679 regspace = setup_sigframe_v2_vfp(regspace, env);
1680 }
Peter Maydell08e11252010-11-24 15:20:07 +00001681 if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
1682 regspace = setup_sigframe_v2_iwmmxt(regspace, env);
1683 }
1684
Peter Maydell0d871bd2010-11-24 15:20:05 +00001685 /* Write terminating magic word */
1686 __put_user(0, regspace);
1687
pbrooka8c33202008-05-07 23:22:46 +00001688 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1689 __put_user(set->sig[i], &uc->tuc_sigmask.sig[i]);
1690 }
1691}
1692
1693/* compare linux/arch/arm/kernel/signal.c:setup_frame() */
pbrook624f7972008-05-31 16:11:38 +00001694static void setup_frame_v1(int usig, struct target_sigaction *ka,
Andreas Färber05390242012-02-25 03:37:53 +01001695 target_sigset_t *set, CPUARMState *regs)
pbrooka8c33202008-05-07 23:22:46 +00001696{
1697 struct sigframe_v1 *frame;
bellard579a97f2007-11-11 14:26:47 +00001698 abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
pbrooka8c33202008-05-07 23:22:46 +00001699 int i;
bellard43fff232003-07-09 19:31:39 +00001700
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01001701 trace_user_setup_frame(regs, frame_addr);
bellard579a97f2007-11-11 14:26:47 +00001702 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1703 return;
1704
pbrooka8c33202008-05-07 23:22:46 +00001705 setup_sigcontext(&frame->sc, regs, set->sig[0]);
bellard43fff232003-07-09 19:31:39 +00001706
Riku Voipio0188fad2014-04-23 13:34:15 +03001707 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1708 __put_user(set->sig[i], &frame->extramask[i - 1]);
1709 }
bellard43fff232003-07-09 19:31:39 +00001710
pbrooka8c33202008-05-07 23:22:46 +00001711 setup_return(regs, ka, &frame->retcode, frame_addr, usig,
1712 frame_addr + offsetof(struct sigframe_v1, retcode));
bellard579a97f2007-11-11 14:26:47 +00001713
bellard579a97f2007-11-11 14:26:47 +00001714 unlock_user_struct(frame, frame_addr, 1);
pbrooka8c33202008-05-07 23:22:46 +00001715}
1716
pbrook624f7972008-05-31 16:11:38 +00001717static void setup_frame_v2(int usig, struct target_sigaction *ka,
Andreas Färber05390242012-02-25 03:37:53 +01001718 target_sigset_t *set, CPUARMState *regs)
pbrooka8c33202008-05-07 23:22:46 +00001719{
1720 struct sigframe_v2 *frame;
1721 abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
1722
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01001723 trace_user_setup_frame(regs, frame_addr);
pbrooka8c33202008-05-07 23:22:46 +00001724 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1725 return;
1726
1727 setup_sigframe_v2(&frame->uc, set, regs);
1728
1729 setup_return(regs, ka, &frame->retcode, frame_addr, usig,
1730 frame_addr + offsetof(struct sigframe_v2, retcode));
1731
1732 unlock_user_struct(frame, frame_addr, 1);
1733}
1734
pbrook624f7972008-05-31 16:11:38 +00001735static void setup_frame(int usig, struct target_sigaction *ka,
Andreas Färber05390242012-02-25 03:37:53 +01001736 target_sigset_t *set, CPUARMState *regs)
pbrooka8c33202008-05-07 23:22:46 +00001737{
1738 if (get_osversion() >= 0x020612) {
1739 setup_frame_v2(usig, ka, set, regs);
1740 } else {
1741 setup_frame_v1(usig, ka, set, regs);
1742 }
bellard43fff232003-07-09 19:31:39 +00001743}
1744
bellard579a97f2007-11-11 14:26:47 +00001745/* compare linux/arch/arm/kernel/signal.c:setup_rt_frame() */
pbrook624f7972008-05-31 16:11:38 +00001746static void setup_rt_frame_v1(int usig, struct target_sigaction *ka,
Anthony Liguoric227f092009-10-01 16:12:16 -05001747 target_siginfo_t *info,
Andreas Färber05390242012-02-25 03:37:53 +01001748 target_sigset_t *set, CPUARMState *env)
bellard43fff232003-07-09 19:31:39 +00001749{
pbrooka745ec62008-05-06 15:36:17 +00001750 struct rt_sigframe_v1 *frame;
bellard579a97f2007-11-11 14:26:47 +00001751 abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
thsa04e1342007-09-27 13:57:58 +00001752 struct target_sigaltstack stack;
pbrooka8c33202008-05-07 23:22:46 +00001753 int i;
bellardf8b0aa22007-11-11 23:03:42 +00001754 abi_ulong info_addr, uc_addr;
bellard43fff232003-07-09 19:31:39 +00001755
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01001756 trace_user_setup_rt_frame(env, frame_addr);
bellard579a97f2007-11-11 14:26:47 +00001757 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
bellardedf779f2004-02-22 13:40:13 +00001758 return /* 1 */;
1759
pbrooka745ec62008-05-06 15:36:17 +00001760 info_addr = frame_addr + offsetof(struct rt_sigframe_v1, info);
pbrooka8c33202008-05-07 23:22:46 +00001761 __put_user(info_addr, &frame->pinfo);
pbrooka745ec62008-05-06 15:36:17 +00001762 uc_addr = frame_addr + offsetof(struct rt_sigframe_v1, uc);
pbrooka8c33202008-05-07 23:22:46 +00001763 __put_user(uc_addr, &frame->puc);
Peter Maydellf6c7a052015-01-08 12:19:48 +00001764 tswap_siginfo(&frame->info, info);
bellard43fff232003-07-09 19:31:39 +00001765
1766 /* Clear all the bits of the ucontext we don't use. */
pbrooka745ec62008-05-06 15:36:17 +00001767 memset(&frame->uc, 0, offsetof(struct target_ucontext_v1, tuc_mcontext));
bellard43fff232003-07-09 19:31:39 +00001768
thsa04e1342007-09-27 13:57:58 +00001769 memset(&stack, 0, sizeof(stack));
1770 __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp);
1771 __put_user(target_sigaltstack_used.ss_size, &stack.ss_size);
1772 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags);
bellard775b58d2007-11-11 16:22:17 +00001773 memcpy(&frame->uc.tuc_stack, &stack, sizeof(stack));
thsa04e1342007-09-27 13:57:58 +00001774
pbrooka8c33202008-05-07 23:22:46 +00001775 setup_sigcontext(&frame->uc.tuc_mcontext, env, set->sig[0]);
bellard92319442004-06-19 16:58:13 +00001776 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
Riku Voipio0188fad2014-04-23 13:34:15 +03001777 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
bellard92319442004-06-19 16:58:13 +00001778 }
bellard43fff232003-07-09 19:31:39 +00001779
pbrooka8c33202008-05-07 23:22:46 +00001780 setup_return(env, ka, &frame->retcode, frame_addr, usig,
1781 frame_addr + offsetof(struct rt_sigframe_v1, retcode));
pbrooka745ec62008-05-06 15:36:17 +00001782
pbrooka8c33202008-05-07 23:22:46 +00001783 env->regs[1] = info_addr;
1784 env->regs[2] = uc_addr;
pbrooka745ec62008-05-06 15:36:17 +00001785
pbrooka745ec62008-05-06 15:36:17 +00001786 unlock_user_struct(frame, frame_addr, 1);
pbrooka745ec62008-05-06 15:36:17 +00001787}
1788
pbrook624f7972008-05-31 16:11:38 +00001789static void setup_rt_frame_v2(int usig, struct target_sigaction *ka,
Anthony Liguoric227f092009-10-01 16:12:16 -05001790 target_siginfo_t *info,
Andreas Färber05390242012-02-25 03:37:53 +01001791 target_sigset_t *set, CPUARMState *env)
pbrooka745ec62008-05-06 15:36:17 +00001792{
1793 struct rt_sigframe_v2 *frame;
1794 abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
pbrooka745ec62008-05-06 15:36:17 +00001795 abi_ulong info_addr, uc_addr;
1796
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01001797 trace_user_setup_rt_frame(env, frame_addr);
pbrooka745ec62008-05-06 15:36:17 +00001798 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1799 return /* 1 */;
1800
1801 info_addr = frame_addr + offsetof(struct rt_sigframe_v2, info);
1802 uc_addr = frame_addr + offsetof(struct rt_sigframe_v2, uc);
Peter Maydellf6c7a052015-01-08 12:19:48 +00001803 tswap_siginfo(&frame->info, info);
pbrooka745ec62008-05-06 15:36:17 +00001804
pbrooka8c33202008-05-07 23:22:46 +00001805 setup_sigframe_v2(&frame->uc, set, env);
pbrooka745ec62008-05-06 15:36:17 +00001806
pbrooka8c33202008-05-07 23:22:46 +00001807 setup_return(env, ka, &frame->retcode, frame_addr, usig,
1808 frame_addr + offsetof(struct rt_sigframe_v2, retcode));
pbrooka745ec62008-05-06 15:36:17 +00001809
pbrooka8c33202008-05-07 23:22:46 +00001810 env->regs[1] = info_addr;
1811 env->regs[2] = uc_addr;
pbrooka745ec62008-05-06 15:36:17 +00001812
bellard579a97f2007-11-11 14:26:47 +00001813 unlock_user_struct(frame, frame_addr, 1);
bellard43fff232003-07-09 19:31:39 +00001814}
1815
pbrook624f7972008-05-31 16:11:38 +00001816static void setup_rt_frame(int usig, struct target_sigaction *ka,
Anthony Liguoric227f092009-10-01 16:12:16 -05001817 target_siginfo_t *info,
Andreas Färber05390242012-02-25 03:37:53 +01001818 target_sigset_t *set, CPUARMState *env)
pbrooka745ec62008-05-06 15:36:17 +00001819{
1820 if (get_osversion() >= 0x020612) {
1821 setup_rt_frame_v2(usig, ka, info, set, env);
1822 } else {
1823 setup_rt_frame_v1(usig, ka, info, set, env);
1824 }
1825}
1826
bellard43fff232003-07-09 19:31:39 +00001827static int
Andreas Färber05390242012-02-25 03:37:53 +01001828restore_sigcontext(CPUARMState *env, struct target_sigcontext *sc)
bellard43fff232003-07-09 19:31:39 +00001829{
1830 int err = 0;
bellardb5ff1b32005-11-26 10:38:39 +00001831 uint32_t cpsr;
bellard43fff232003-07-09 19:31:39 +00001832
Riku Voipio1d8b5122014-04-23 10:26:05 +03001833 __get_user(env->regs[0], &sc->arm_r0);
1834 __get_user(env->regs[1], &sc->arm_r1);
1835 __get_user(env->regs[2], &sc->arm_r2);
1836 __get_user(env->regs[3], &sc->arm_r3);
1837 __get_user(env->regs[4], &sc->arm_r4);
1838 __get_user(env->regs[5], &sc->arm_r5);
1839 __get_user(env->regs[6], &sc->arm_r6);
1840 __get_user(env->regs[7], &sc->arm_r7);
1841 __get_user(env->regs[8], &sc->arm_r8);
1842 __get_user(env->regs[9], &sc->arm_r9);
1843 __get_user(env->regs[10], &sc->arm_r10);
1844 __get_user(env->regs[11], &sc->arm_fp);
1845 __get_user(env->regs[12], &sc->arm_ip);
1846 __get_user(env->regs[13], &sc->arm_sp);
1847 __get_user(env->regs[14], &sc->arm_lr);
1848 __get_user(env->regs[15], &sc->arm_pc);
bellard43fff232003-07-09 19:31:39 +00001849#ifdef TARGET_CONFIG_CPU_32
Riku Voipio1d8b5122014-04-23 10:26:05 +03001850 __get_user(cpsr, &sc->arm_cpsr);
pbrook75b680e2008-03-21 16:07:30 +00001851 cpsr_write(env, cpsr, CPSR_USER | CPSR_EXEC);
bellard43fff232003-07-09 19:31:39 +00001852#endif
1853
1854 err |= !valid_user_regs(env);
1855
1856 return err;
1857}
1858
Andreas Färber05390242012-02-25 03:37:53 +01001859static long do_sigreturn_v1(CPUARMState *env)
bellard43fff232003-07-09 19:31:39 +00001860{
bellardf8b0aa22007-11-11 23:03:42 +00001861 abi_ulong frame_addr;
Peter Maydell978fae92013-07-29 12:00:32 +01001862 struct sigframe_v1 *frame = NULL;
Anthony Liguoric227f092009-10-01 16:12:16 -05001863 target_sigset_t set;
bellard43fff232003-07-09 19:31:39 +00001864 sigset_t host_set;
bellard92319442004-06-19 16:58:13 +00001865 int i;
bellard43fff232003-07-09 19:31:39 +00001866
1867 /*
1868 * Since we stacked the signal on a 64-bit boundary,
1869 * then 'sp' should be word aligned here. If it's
1870 * not, then the user is trying to mess with us.
1871 */
bellardf8b0aa22007-11-11 23:03:42 +00001872 frame_addr = env->regs[13];
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01001873 trace_user_do_sigreturn(env, frame_addr);
Peter Maydell978fae92013-07-29 12:00:32 +01001874 if (frame_addr & 7) {
1875 goto badframe;
1876 }
1877
bellardf8b0aa22007-11-11 23:03:42 +00001878 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1879 goto badframe;
bellard43fff232003-07-09 19:31:39 +00001880
Riku Voipiof5f601a2014-04-23 13:00:17 +03001881 __get_user(set.sig[0], &frame->sc.oldmask);
1882 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1883 __get_user(set.sig[i], &frame->extramask[i - 1]);
1884 }
bellard43fff232003-07-09 19:31:39 +00001885
bellard92319442004-06-19 16:58:13 +00001886 target_to_host_sigset_internal(&host_set, &set);
Alex Barcelo1c275922014-03-14 14:36:55 +00001887 do_sigprocmask(SIG_SETMASK, &host_set, NULL);
bellard43fff232003-07-09 19:31:39 +00001888
1889 if (restore_sigcontext(env, &frame->sc))
1890 goto badframe;
1891
1892#if 0
1893 /* Send SIGTRAP if we're single-stepping */
1894 if (ptrace_cancel_bpt(current))
1895 send_sig(SIGTRAP, current, 1);
1896#endif
bellardf8b0aa22007-11-11 23:03:42 +00001897 unlock_user_struct(frame, frame_addr, 0);
1898 return env->regs[0];
bellard43fff232003-07-09 19:31:39 +00001899
1900badframe:
Riku Voipio66393fb2009-12-04 15:16:32 +02001901 force_sig(TARGET_SIGSEGV /* , current */);
bellard43fff232003-07-09 19:31:39 +00001902 return 0;
1903}
1904
Andreas Färber05390242012-02-25 03:37:53 +01001905static abi_ulong *restore_sigframe_v2_vfp(CPUARMState *env, abi_ulong *regspace)
Peter Maydell5f9099d2010-11-24 15:20:06 +00001906{
1907 int i;
1908 abi_ulong magic, sz;
1909 uint32_t fpscr, fpexc;
1910 struct target_vfp_sigframe *vfpframe;
1911 vfpframe = (struct target_vfp_sigframe *)regspace;
1912
1913 __get_user(magic, &vfpframe->magic);
1914 __get_user(sz, &vfpframe->size);
1915 if (magic != TARGET_VFP_MAGIC || sz != sizeof(*vfpframe)) {
1916 return 0;
1917 }
1918 for (i = 0; i < 32; i++) {
Peter Maydell005e1a02011-02-10 13:59:35 +00001919 __get_user(float64_val(env->vfp.regs[i]), &vfpframe->ufp.fpregs[i]);
Peter Maydell5f9099d2010-11-24 15:20:06 +00001920 }
1921 __get_user(fpscr, &vfpframe->ufp.fpscr);
1922 vfp_set_fpscr(env, fpscr);
1923 __get_user(fpexc, &vfpframe->ufp_exc.fpexc);
1924 /* Sanitise FPEXC: ensure VFP is enabled, FPINST2 is invalid
1925 * and the exception flag is cleared
1926 */
1927 fpexc |= (1 << 30);
1928 fpexc &= ~((1 << 31) | (1 << 28));
1929 env->vfp.xregs[ARM_VFP_FPEXC] = fpexc;
1930 __get_user(env->vfp.xregs[ARM_VFP_FPINST], &vfpframe->ufp_exc.fpinst);
1931 __get_user(env->vfp.xregs[ARM_VFP_FPINST2], &vfpframe->ufp_exc.fpinst2);
1932 return (abi_ulong*)(vfpframe + 1);
1933}
1934
Andreas Färber05390242012-02-25 03:37:53 +01001935static abi_ulong *restore_sigframe_v2_iwmmxt(CPUARMState *env,
1936 abi_ulong *regspace)
Peter Maydella59d69d2010-11-24 15:20:08 +00001937{
1938 int i;
1939 abi_ulong magic, sz;
1940 struct target_iwmmxt_sigframe *iwmmxtframe;
1941 iwmmxtframe = (struct target_iwmmxt_sigframe *)regspace;
1942
1943 __get_user(magic, &iwmmxtframe->magic);
1944 __get_user(sz, &iwmmxtframe->size);
1945 if (magic != TARGET_IWMMXT_MAGIC || sz != sizeof(*iwmmxtframe)) {
1946 return 0;
1947 }
1948 for (i = 0; i < 16; i++) {
1949 __get_user(env->iwmmxt.regs[i], &iwmmxtframe->regs[i]);
1950 }
1951 __get_user(env->vfp.xregs[ARM_IWMMXT_wCSSF], &iwmmxtframe->wcssf);
1952 __get_user(env->vfp.xregs[ARM_IWMMXT_wCASF], &iwmmxtframe->wcssf);
1953 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR0], &iwmmxtframe->wcgr0);
1954 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR1], &iwmmxtframe->wcgr1);
1955 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR2], &iwmmxtframe->wcgr2);
1956 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR3], &iwmmxtframe->wcgr3);
1957 return (abi_ulong*)(iwmmxtframe + 1);
1958}
1959
Andreas Färber05390242012-02-25 03:37:53 +01001960static int do_sigframe_return_v2(CPUARMState *env, target_ulong frame_addr,
pbrooka8c33202008-05-07 23:22:46 +00001961 struct target_ucontext_v2 *uc)
1962{
1963 sigset_t host_set;
Peter Maydell5f9099d2010-11-24 15:20:06 +00001964 abi_ulong *regspace;
pbrooka8c33202008-05-07 23:22:46 +00001965
1966 target_to_host_sigset(&host_set, &uc->tuc_sigmask);
Alex Barcelo1c275922014-03-14 14:36:55 +00001967 do_sigprocmask(SIG_SETMASK, &host_set, NULL);
pbrooka8c33202008-05-07 23:22:46 +00001968
1969 if (restore_sigcontext(env, &uc->tuc_mcontext))
1970 return 1;
1971
Peter Maydell5f9099d2010-11-24 15:20:06 +00001972 /* Restore coprocessor signal frame */
1973 regspace = uc->tuc_regspace;
1974 if (arm_feature(env, ARM_FEATURE_VFP)) {
1975 regspace = restore_sigframe_v2_vfp(env, regspace);
1976 if (!regspace) {
1977 return 1;
1978 }
1979 }
Peter Maydella59d69d2010-11-24 15:20:08 +00001980 if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
1981 regspace = restore_sigframe_v2_iwmmxt(env, regspace);
1982 if (!regspace) {
1983 return 1;
1984 }
1985 }
Peter Maydell5f9099d2010-11-24 15:20:06 +00001986
pbrooka8c33202008-05-07 23:22:46 +00001987 if (do_sigaltstack(frame_addr + offsetof(struct target_ucontext_v2, tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT)
1988 return 1;
1989
1990#if 0
1991 /* Send SIGTRAP if we're single-stepping */
1992 if (ptrace_cancel_bpt(current))
1993 send_sig(SIGTRAP, current, 1);
1994#endif
1995
1996 return 0;
1997}
1998
Andreas Färber05390242012-02-25 03:37:53 +01001999static long do_sigreturn_v2(CPUARMState *env)
pbrooka8c33202008-05-07 23:22:46 +00002000{
2001 abi_ulong frame_addr;
Peter Maydell978fae92013-07-29 12:00:32 +01002002 struct sigframe_v2 *frame = NULL;
pbrooka8c33202008-05-07 23:22:46 +00002003
2004 /*
2005 * Since we stacked the signal on a 64-bit boundary,
2006 * then 'sp' should be word aligned here. If it's
2007 * not, then the user is trying to mess with us.
2008 */
pbrooka8c33202008-05-07 23:22:46 +00002009 frame_addr = env->regs[13];
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01002010 trace_user_do_sigreturn(env, frame_addr);
Peter Maydell978fae92013-07-29 12:00:32 +01002011 if (frame_addr & 7) {
2012 goto badframe;
2013 }
2014
pbrooka8c33202008-05-07 23:22:46 +00002015 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
2016 goto badframe;
2017
2018 if (do_sigframe_return_v2(env, frame_addr, &frame->uc))
2019 goto badframe;
2020
2021 unlock_user_struct(frame, frame_addr, 0);
2022 return env->regs[0];
2023
2024badframe:
2025 unlock_user_struct(frame, frame_addr, 0);
Riku Voipio66393fb2009-12-04 15:16:32 +02002026 force_sig(TARGET_SIGSEGV /* , current */);
pbrooka8c33202008-05-07 23:22:46 +00002027 return 0;
2028}
2029
Andreas Färber05390242012-02-25 03:37:53 +01002030long do_sigreturn(CPUARMState *env)
pbrooka8c33202008-05-07 23:22:46 +00002031{
2032 if (get_osversion() >= 0x020612) {
2033 return do_sigreturn_v2(env);
2034 } else {
2035 return do_sigreturn_v1(env);
2036 }
2037}
2038
Andreas Färber05390242012-02-25 03:37:53 +01002039static long do_rt_sigreturn_v1(CPUARMState *env)
bellard43fff232003-07-09 19:31:39 +00002040{
bellardf8b0aa22007-11-11 23:03:42 +00002041 abi_ulong frame_addr;
Peter Maydell978fae92013-07-29 12:00:32 +01002042 struct rt_sigframe_v1 *frame = NULL;
bellard43fff232003-07-09 19:31:39 +00002043 sigset_t host_set;
2044
2045 /*
2046 * Since we stacked the signal on a 64-bit boundary,
2047 * then 'sp' should be word aligned here. If it's
2048 * not, then the user is trying to mess with us.
2049 */
bellardf8b0aa22007-11-11 23:03:42 +00002050 frame_addr = env->regs[13];
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01002051 trace_user_do_rt_sigreturn(env, frame_addr);
Peter Maydell978fae92013-07-29 12:00:32 +01002052 if (frame_addr & 7) {
2053 goto badframe;
2054 }
2055
bellardf8b0aa22007-11-11 23:03:42 +00002056 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
2057 goto badframe;
bellard43fff232003-07-09 19:31:39 +00002058
bellardb8076a72005-04-07 22:20:31 +00002059 target_to_host_sigset(&host_set, &frame->uc.tuc_sigmask);
Alex Barcelo1c275922014-03-14 14:36:55 +00002060 do_sigprocmask(SIG_SETMASK, &host_set, NULL);
bellard43fff232003-07-09 19:31:39 +00002061
bellardb8076a72005-04-07 22:20:31 +00002062 if (restore_sigcontext(env, &frame->uc.tuc_mcontext))
bellard43fff232003-07-09 19:31:39 +00002063 goto badframe;
2064
pbrooka745ec62008-05-06 15:36:17 +00002065 if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe_v1, uc.tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT)
thsa04e1342007-09-27 13:57:58 +00002066 goto badframe;
2067
bellard43fff232003-07-09 19:31:39 +00002068#if 0
2069 /* Send SIGTRAP if we're single-stepping */
2070 if (ptrace_cancel_bpt(current))
2071 send_sig(SIGTRAP, current, 1);
2072#endif
bellardf8b0aa22007-11-11 23:03:42 +00002073 unlock_user_struct(frame, frame_addr, 0);
bellard43fff232003-07-09 19:31:39 +00002074 return env->regs[0];
2075
2076badframe:
bellardf8b0aa22007-11-11 23:03:42 +00002077 unlock_user_struct(frame, frame_addr, 0);
Riku Voipio66393fb2009-12-04 15:16:32 +02002078 force_sig(TARGET_SIGSEGV /* , current */);
bellard43fff232003-07-09 19:31:39 +00002079 return 0;
2080}
2081
Andreas Färber05390242012-02-25 03:37:53 +01002082static long do_rt_sigreturn_v2(CPUARMState *env)
pbrooka745ec62008-05-06 15:36:17 +00002083{
2084 abi_ulong frame_addr;
Peter Maydell978fae92013-07-29 12:00:32 +01002085 struct rt_sigframe_v2 *frame = NULL;
pbrooka745ec62008-05-06 15:36:17 +00002086
2087 /*
2088 * Since we stacked the signal on a 64-bit boundary,
2089 * then 'sp' should be word aligned here. If it's
2090 * not, then the user is trying to mess with us.
2091 */
pbrooka745ec62008-05-06 15:36:17 +00002092 frame_addr = env->regs[13];
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01002093 trace_user_do_rt_sigreturn(env, frame_addr);
Peter Maydell978fae92013-07-29 12:00:32 +01002094 if (frame_addr & 7) {
2095 goto badframe;
2096 }
2097
pbrooka745ec62008-05-06 15:36:17 +00002098 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
2099 goto badframe;
2100
pbrooka8c33202008-05-07 23:22:46 +00002101 if (do_sigframe_return_v2(env, frame_addr, &frame->uc))
2102 goto badframe;
pbrooka745ec62008-05-06 15:36:17 +00002103
pbrooka745ec62008-05-06 15:36:17 +00002104 unlock_user_struct(frame, frame_addr, 0);
2105 return env->regs[0];
2106
2107badframe:
2108 unlock_user_struct(frame, frame_addr, 0);
Riku Voipio66393fb2009-12-04 15:16:32 +02002109 force_sig(TARGET_SIGSEGV /* , current */);
pbrooka745ec62008-05-06 15:36:17 +00002110 return 0;
2111}
2112
Andreas Färber05390242012-02-25 03:37:53 +01002113long do_rt_sigreturn(CPUARMState *env)
pbrooka745ec62008-05-06 15:36:17 +00002114{
2115 if (get_osversion() >= 0x020612) {
2116 return do_rt_sigreturn_v2(env);
2117 } else {
2118 return do_rt_sigreturn_v1(env);
2119 }
2120}
2121
bellard6d5e2162004-09-30 22:04:13 +00002122#elif defined(TARGET_SPARC)
bellard80a9d032005-01-03 23:31:27 +00002123
bellard6d5e2162004-09-30 22:04:13 +00002124#define __SUNOS_MAXWIN 31
2125
2126/* This is what SunOS does, so shall I. */
2127struct target_sigcontext {
blueswir1992f48a2007-10-14 16:27:31 +00002128 abi_ulong sigc_onstack; /* state to restore */
bellard6d5e2162004-09-30 22:04:13 +00002129
blueswir1992f48a2007-10-14 16:27:31 +00002130 abi_ulong sigc_mask; /* sigmask to restore */
2131 abi_ulong sigc_sp; /* stack pointer */
2132 abi_ulong sigc_pc; /* program counter */
2133 abi_ulong sigc_npc; /* next program counter */
2134 abi_ulong sigc_psr; /* for condition codes etc */
2135 abi_ulong sigc_g1; /* User uses these two registers */
2136 abi_ulong sigc_o0; /* within the trampoline code. */
bellard6d5e2162004-09-30 22:04:13 +00002137
2138 /* Now comes information regarding the users window set
2139 * at the time of the signal.
2140 */
blueswir1992f48a2007-10-14 16:27:31 +00002141 abi_ulong sigc_oswins; /* outstanding windows */
bellard6d5e2162004-09-30 22:04:13 +00002142
2143 /* stack ptrs for each regwin buf */
2144 char *sigc_spbuf[__SUNOS_MAXWIN];
2145
2146 /* Windows to restore after signal */
2147 struct {
blueswir1992f48a2007-10-14 16:27:31 +00002148 abi_ulong locals[8];
2149 abi_ulong ins[8];
bellard6d5e2162004-09-30 22:04:13 +00002150 } sigc_wbuf[__SUNOS_MAXWIN];
2151};
2152/* A Sparc stack frame */
2153struct sparc_stackf {
blueswir1992f48a2007-10-14 16:27:31 +00002154 abi_ulong locals[8];
Peter Maydelle321c342011-02-01 15:54:52 +00002155 abi_ulong ins[8];
2156 /* It's simpler to treat fp and callers_pc as elements of ins[]
2157 * since we never need to access them ourselves.
2158 */
bellard6d5e2162004-09-30 22:04:13 +00002159 char *structptr;
blueswir1992f48a2007-10-14 16:27:31 +00002160 abi_ulong xargs[6];
2161 abi_ulong xxargs[1];
bellard6d5e2162004-09-30 22:04:13 +00002162};
2163
2164typedef struct {
2165 struct {
blueswir1992f48a2007-10-14 16:27:31 +00002166 abi_ulong psr;
2167 abi_ulong pc;
2168 abi_ulong npc;
2169 abi_ulong y;
2170 abi_ulong u_regs[16]; /* globals and ins */
bellard6d5e2162004-09-30 22:04:13 +00002171 } si_regs;
2172 int si_mask;
2173} __siginfo_t;
2174
2175typedef struct {
Blue Swirl8954bae2012-07-30 15:29:11 +00002176 abi_ulong si_float_regs[32];
bellard6d5e2162004-09-30 22:04:13 +00002177 unsigned long si_fsr;
2178 unsigned long si_fpqdepth;
2179 struct {
2180 unsigned long *insn_addr;
2181 unsigned long insn;
2182 } si_fpqueue [16];
Anthony Liguoric227f092009-10-01 16:12:16 -05002183} qemu_siginfo_fpu_t;
bellard6d5e2162004-09-30 22:04:13 +00002184
2185
2186struct target_signal_frame {
2187 struct sparc_stackf ss;
2188 __siginfo_t info;
bellardf8b0aa22007-11-11 23:03:42 +00002189 abi_ulong fpu_save;
blueswir1992f48a2007-10-14 16:27:31 +00002190 abi_ulong insns[2] __attribute__ ((aligned (8)));
2191 abi_ulong extramask[TARGET_NSIG_WORDS - 1];
2192 abi_ulong extra_size; /* Should be 0 */
Anthony Liguoric227f092009-10-01 16:12:16 -05002193 qemu_siginfo_fpu_t fpu_state;
bellard6d5e2162004-09-30 22:04:13 +00002194};
2195struct target_rt_signal_frame {
2196 struct sparc_stackf ss;
2197 siginfo_t info;
blueswir1992f48a2007-10-14 16:27:31 +00002198 abi_ulong regs[20];
bellard6d5e2162004-09-30 22:04:13 +00002199 sigset_t mask;
bellardf8b0aa22007-11-11 23:03:42 +00002200 abi_ulong fpu_save;
bellard6d5e2162004-09-30 22:04:13 +00002201 unsigned int insns[2];
2202 stack_t stack;
2203 unsigned int extra_size; /* Should be 0 */
Anthony Liguoric227f092009-10-01 16:12:16 -05002204 qemu_siginfo_fpu_t fpu_state;
bellard6d5e2162004-09-30 22:04:13 +00002205};
2206
bellarde80cfcf2004-12-19 23:18:01 +00002207#define UREG_O0 16
2208#define UREG_O6 22
2209#define UREG_I0 0
2210#define UREG_I1 1
2211#define UREG_I2 2
blueswir15bfb56b2007-10-05 17:01:51 +00002212#define UREG_I3 3
2213#define UREG_I4 4
2214#define UREG_I5 5
bellarde80cfcf2004-12-19 23:18:01 +00002215#define UREG_I6 6
2216#define UREG_I7 7
2217#define UREG_L0 8
bellard6d5e2162004-09-30 22:04:13 +00002218#define UREG_FP UREG_I6
2219#define UREG_SP UREG_O6
2220
pbrook624f7972008-05-31 16:11:38 +00002221static inline abi_ulong get_sigframe(struct target_sigaction *sa,
Andreas Färber05390242012-02-25 03:37:53 +01002222 CPUSPARCState *env,
2223 unsigned long framesize)
bellard6d5e2162004-09-30 22:04:13 +00002224{
bellard459a4012007-11-11 19:45:10 +00002225 abi_ulong sp;
bellard6d5e2162004-09-30 22:04:13 +00002226
2227 sp = env->regwptr[UREG_FP];
bellard6d5e2162004-09-30 22:04:13 +00002228
2229 /* This is the X/Open sanctioned signal stack switching. */
pbrook624f7972008-05-31 16:11:38 +00002230 if (sa->sa_flags & TARGET_SA_ONSTACK) {
thsa04e1342007-09-27 13:57:58 +00002231 if (!on_sig_stack(sp)
2232 && !((target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size) & 7))
2233 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
bellard6d5e2162004-09-30 22:04:13 +00002234 }
bellard459a4012007-11-11 19:45:10 +00002235 return sp - framesize;
bellard6d5e2162004-09-30 22:04:13 +00002236}
2237
2238static int
Andreas Färber05390242012-02-25 03:37:53 +01002239setup___siginfo(__siginfo_t *si, CPUSPARCState *env, abi_ulong mask)
bellard6d5e2162004-09-30 22:04:13 +00002240{
2241 int err = 0, i;
2242
Riku Voipio1d8b5122014-04-23 10:26:05 +03002243 __put_user(env->psr, &si->si_regs.psr);
2244 __put_user(env->pc, &si->si_regs.pc);
2245 __put_user(env->npc, &si->si_regs.npc);
2246 __put_user(env->y, &si->si_regs.y);
bellarda315a142005-01-30 22:59:18 +00002247 for (i=0; i < 8; i++) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03002248 __put_user(env->gregs[i], &si->si_regs.u_regs[i]);
bellard6d5e2162004-09-30 22:04:13 +00002249 }
bellarda315a142005-01-30 22:59:18 +00002250 for (i=0; i < 8; i++) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03002251 __put_user(env->regwptr[UREG_I0 + i], &si->si_regs.u_regs[i+8]);
bellard6d5e2162004-09-30 22:04:13 +00002252 }
Riku Voipio1d8b5122014-04-23 10:26:05 +03002253 __put_user(mask, &si->si_mask);
bellard6d5e2162004-09-30 22:04:13 +00002254 return err;
2255}
bellarde80cfcf2004-12-19 23:18:01 +00002256
bellard80a9d032005-01-03 23:31:27 +00002257#if 0
bellard6d5e2162004-09-30 22:04:13 +00002258static int
2259setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
Andreas Färber05390242012-02-25 03:37:53 +01002260 CPUSPARCState *env, unsigned long mask)
bellard6d5e2162004-09-30 22:04:13 +00002261{
2262 int err = 0;
2263
Riku Voipio1d8b5122014-04-23 10:26:05 +03002264 __put_user(mask, &sc->sigc_mask);
2265 __put_user(env->regwptr[UREG_SP], &sc->sigc_sp);
2266 __put_user(env->pc, &sc->sigc_pc);
2267 __put_user(env->npc, &sc->sigc_npc);
2268 __put_user(env->psr, &sc->sigc_psr);
2269 __put_user(env->gregs[1], &sc->sigc_g1);
2270 __put_user(env->regwptr[UREG_O0], &sc->sigc_o0);
bellard6d5e2162004-09-30 22:04:13 +00002271
2272 return err;
2273}
bellard80a9d032005-01-03 23:31:27 +00002274#endif
bellard6d5e2162004-09-30 22:04:13 +00002275#define NF_ALIGNEDSZ (((sizeof(struct target_signal_frame) + 7) & (~7)))
2276
pbrook624f7972008-05-31 16:11:38 +00002277static void setup_frame(int sig, struct target_sigaction *ka,
Andreas Färber05390242012-02-25 03:37:53 +01002278 target_sigset_t *set, CPUSPARCState *env)
bellard6d5e2162004-09-30 22:04:13 +00002279{
bellard459a4012007-11-11 19:45:10 +00002280 abi_ulong sf_addr;
bellard6d5e2162004-09-30 22:04:13 +00002281 struct target_signal_frame *sf;
2282 int sigframe_size, err, i;
2283
2284 /* 1. Make sure everything is clean */
2285 //synchronize_user_stack();
2286
2287 sigframe_size = NF_ALIGNEDSZ;
bellard459a4012007-11-11 19:45:10 +00002288 sf_addr = get_sigframe(ka, env, sigframe_size);
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01002289 trace_user_setup_frame(env, sf_addr);
bellard6d5e2162004-09-30 22:04:13 +00002290
bellard459a4012007-11-11 19:45:10 +00002291 sf = lock_user(VERIFY_WRITE, sf_addr,
2292 sizeof(struct target_signal_frame), 0);
2293 if (!sf)
2294 goto sigsegv;
2295
bellard6d5e2162004-09-30 22:04:13 +00002296#if 0
2297 if (invalid_frame_pointer(sf, sigframe_size))
2298 goto sigill_and_return;
2299#endif
2300 /* 2. Save the current process state */
2301 err = setup___siginfo(&sf->info, env, set->sig[0]);
Riku Voipio1d8b5122014-04-23 10:26:05 +03002302 __put_user(0, &sf->extra_size);
bellard6d5e2162004-09-30 22:04:13 +00002303
Riku Voipio1d8b5122014-04-23 10:26:05 +03002304 //save_fpu_state(regs, &sf->fpu_state);
2305 //__put_user(&sf->fpu_state, &sf->fpu_save);
bellard6d5e2162004-09-30 22:04:13 +00002306
Riku Voipio1d8b5122014-04-23 10:26:05 +03002307 __put_user(set->sig[0], &sf->info.si_mask);
bellard6d5e2162004-09-30 22:04:13 +00002308 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03002309 __put_user(set->sig[i + 1], &sf->extramask[i]);
bellard6d5e2162004-09-30 22:04:13 +00002310 }
2311
bellarda315a142005-01-30 22:59:18 +00002312 for (i = 0; i < 8; i++) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03002313 __put_user(env->regwptr[i + UREG_L0], &sf->ss.locals[i]);
bellard6d5e2162004-09-30 22:04:13 +00002314 }
bellarda315a142005-01-30 22:59:18 +00002315 for (i = 0; i < 8; i++) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03002316 __put_user(env->regwptr[i + UREG_I0], &sf->ss.ins[i]);
bellard6d5e2162004-09-30 22:04:13 +00002317 }
bellard6d5e2162004-09-30 22:04:13 +00002318 if (err)
2319 goto sigsegv;
2320
2321 /* 3. signal handler back-trampoline and parameters */
bellard459a4012007-11-11 19:45:10 +00002322 env->regwptr[UREG_FP] = sf_addr;
bellard6d5e2162004-09-30 22:04:13 +00002323 env->regwptr[UREG_I0] = sig;
bellard459a4012007-11-11 19:45:10 +00002324 env->regwptr[UREG_I1] = sf_addr +
2325 offsetof(struct target_signal_frame, info);
2326 env->regwptr[UREG_I2] = sf_addr +
2327 offsetof(struct target_signal_frame, info);
bellard6d5e2162004-09-30 22:04:13 +00002328
2329 /* 4. signal handler */
pbrook624f7972008-05-31 16:11:38 +00002330 env->pc = ka->_sa_handler;
bellard6d5e2162004-09-30 22:04:13 +00002331 env->npc = (env->pc + 4);
2332 /* 5. return to kernel instructions */
pbrook624f7972008-05-31 16:11:38 +00002333 if (ka->sa_restorer)
2334 env->regwptr[UREG_I7] = ka->sa_restorer;
bellard6d5e2162004-09-30 22:04:13 +00002335 else {
bellard775b58d2007-11-11 16:22:17 +00002336 uint32_t val32;
bellard459a4012007-11-11 19:45:10 +00002337
2338 env->regwptr[UREG_I7] = sf_addr +
2339 offsetof(struct target_signal_frame, insns) - 2 * 4;
bellard6d5e2162004-09-30 22:04:13 +00002340
2341 /* mov __NR_sigreturn, %g1 */
bellard775b58d2007-11-11 16:22:17 +00002342 val32 = 0x821020d8;
Riku Voipio1d8b5122014-04-23 10:26:05 +03002343 __put_user(val32, &sf->insns[0]);
bellard6d5e2162004-09-30 22:04:13 +00002344
2345 /* t 0x10 */
bellard775b58d2007-11-11 16:22:17 +00002346 val32 = 0x91d02010;
Riku Voipio1d8b5122014-04-23 10:26:05 +03002347 __put_user(val32, &sf->insns[1]);
bellard6d5e2162004-09-30 22:04:13 +00002348 if (err)
2349 goto sigsegv;
2350
2351 /* Flush instruction space. */
2352 //flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
Peter Crosthwaitebbd77c12015-06-23 19:31:15 -07002353 // tb_flush(CPU(sparc_env_get_cpu(env)));
bellard6d5e2162004-09-30 22:04:13 +00002354 }
bellard459a4012007-11-11 19:45:10 +00002355 unlock_user(sf, sf_addr, sizeof(struct target_signal_frame));
bellard6d5e2162004-09-30 22:04:13 +00002356 return;
bellard459a4012007-11-11 19:45:10 +00002357#if 0
2358sigill_and_return:
bellard6d5e2162004-09-30 22:04:13 +00002359 force_sig(TARGET_SIGILL);
bellard459a4012007-11-11 19:45:10 +00002360#endif
bellard6d5e2162004-09-30 22:04:13 +00002361sigsegv:
bellard459a4012007-11-11 19:45:10 +00002362 unlock_user(sf, sf_addr, sizeof(struct target_signal_frame));
bellard6d5e2162004-09-30 22:04:13 +00002363 force_sig(TARGET_SIGSEGV);
2364}
bellard6d5e2162004-09-30 22:04:13 +00002365
pbrook624f7972008-05-31 16:11:38 +00002366static void setup_rt_frame(int sig, struct target_sigaction *ka,
Anthony Liguoric227f092009-10-01 16:12:16 -05002367 target_siginfo_t *info,
Andreas Färber05390242012-02-25 03:37:53 +01002368 target_sigset_t *set, CPUSPARCState *env)
bellard6d5e2162004-09-30 22:04:13 +00002369{
2370 fprintf(stderr, "setup_rt_frame: not implemented\n");
2371}
2372
Andreas Färber05390242012-02-25 03:37:53 +01002373long do_sigreturn(CPUSPARCState *env)
bellard6d5e2162004-09-30 22:04:13 +00002374{
bellardf8b0aa22007-11-11 23:03:42 +00002375 abi_ulong sf_addr;
bellard6d5e2162004-09-30 22:04:13 +00002376 struct target_signal_frame *sf;
bellarde80cfcf2004-12-19 23:18:01 +00002377 uint32_t up_psr, pc, npc;
Anthony Liguoric227f092009-10-01 16:12:16 -05002378 target_sigset_t set;
bellarde80cfcf2004-12-19 23:18:01 +00002379 sigset_t host_set;
Riku Voipio1d8b5122014-04-23 10:26:05 +03002380 int err=0, i;
bellard6d5e2162004-09-30 22:04:13 +00002381
bellardf8b0aa22007-11-11 23:03:42 +00002382 sf_addr = env->regwptr[UREG_FP];
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01002383 trace_user_do_sigreturn(env, sf_addr);
bellardf8b0aa22007-11-11 23:03:42 +00002384 if (!lock_user_struct(VERIFY_READ, sf, sf_addr, 1))
2385 goto segv_and_exit;
bellard6d5e2162004-09-30 22:04:13 +00002386
2387 /* 1. Make sure we are not getting garbage from the user */
bellard6d5e2162004-09-30 22:04:13 +00002388
bellardf8b0aa22007-11-11 23:03:42 +00002389 if (sf_addr & 3)
bellard6d5e2162004-09-30 22:04:13 +00002390 goto segv_and_exit;
2391
Riku Voipio1d8b5122014-04-23 10:26:05 +03002392 __get_user(pc, &sf->info.si_regs.pc);
2393 __get_user(npc, &sf->info.si_regs.npc);
bellard6d5e2162004-09-30 22:04:13 +00002394
bellard6d5e2162004-09-30 22:04:13 +00002395 if ((pc | npc) & 3)
2396 goto segv_and_exit;
2397
2398 /* 2. Restore the state */
Riku Voipio1d8b5122014-04-23 10:26:05 +03002399 __get_user(up_psr, &sf->info.si_regs.psr);
bellarde80cfcf2004-12-19 23:18:01 +00002400
bellard6d5e2162004-09-30 22:04:13 +00002401 /* User can only change condition codes and FPU enabling in %psr. */
bellarda315a142005-01-30 22:59:18 +00002402 env->psr = (up_psr & (PSR_ICC /* | PSR_EF */))
2403 | (env->psr & ~(PSR_ICC /* | PSR_EF */));
2404
2405 env->pc = pc;
2406 env->npc = npc;
Riku Voipio1d8b5122014-04-23 10:26:05 +03002407 __get_user(env->y, &sf->info.si_regs.y);
bellarda315a142005-01-30 22:59:18 +00002408 for (i=0; i < 8; i++) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03002409 __get_user(env->gregs[i], &sf->info.si_regs.u_regs[i]);
bellarde80cfcf2004-12-19 23:18:01 +00002410 }
bellarda315a142005-01-30 22:59:18 +00002411 for (i=0; i < 8; i++) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03002412 __get_user(env->regwptr[i + UREG_I0], &sf->info.si_regs.u_regs[i+8]);
bellarde80cfcf2004-12-19 23:18:01 +00002413 }
bellard6d5e2162004-09-30 22:04:13 +00002414
Peter Maydell2aec3a22011-06-16 17:37:14 +01002415 /* FIXME: implement FPU save/restore:
2416 * __get_user(fpu_save, &sf->fpu_save);
2417 * if (fpu_save)
2418 * err |= restore_fpu_state(env, fpu_save);
2419 */
bellard6d5e2162004-09-30 22:04:13 +00002420
2421 /* This is pretty much atomic, no amount locking would prevent
2422 * the races which exist anyways.
2423 */
Riku Voipio1d8b5122014-04-23 10:26:05 +03002424 __get_user(set.sig[0], &sf->info.si_mask);
bellarde80cfcf2004-12-19 23:18:01 +00002425 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03002426 __get_user(set.sig[i], &sf->extramask[i - 1]);
bellarde80cfcf2004-12-19 23:18:01 +00002427 }
2428
2429 target_to_host_sigset_internal(&host_set, &set);
Alex Barcelo1c275922014-03-14 14:36:55 +00002430 do_sigprocmask(SIG_SETMASK, &host_set, NULL);
bellard6d5e2162004-09-30 22:04:13 +00002431
2432 if (err)
2433 goto segv_and_exit;
bellardf8b0aa22007-11-11 23:03:42 +00002434 unlock_user_struct(sf, sf_addr, 0);
bellard6d5e2162004-09-30 22:04:13 +00002435 return env->regwptr[0];
2436
2437segv_and_exit:
bellardf8b0aa22007-11-11 23:03:42 +00002438 unlock_user_struct(sf, sf_addr, 0);
bellard6d5e2162004-09-30 22:04:13 +00002439 force_sig(TARGET_SIGSEGV);
2440}
2441
Andreas Färber05390242012-02-25 03:37:53 +01002442long do_rt_sigreturn(CPUSPARCState *env)
bellard6d5e2162004-09-30 22:04:13 +00002443{
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01002444 trace_user_do_rt_sigreturn(env, 0);
bellard6d5e2162004-09-30 22:04:13 +00002445 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
bellardf8b0aa22007-11-11 23:03:42 +00002446 return -TARGET_ENOSYS;
bellard6d5e2162004-09-30 22:04:13 +00002447}
2448
bellard459a4012007-11-11 19:45:10 +00002449#if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
blueswir15bfb56b2007-10-05 17:01:51 +00002450#define MC_TSTATE 0
2451#define MC_PC 1
2452#define MC_NPC 2
2453#define MC_Y 3
2454#define MC_G1 4
2455#define MC_G2 5
2456#define MC_G3 6
2457#define MC_G4 7
2458#define MC_G5 8
2459#define MC_G6 9
2460#define MC_G7 10
2461#define MC_O0 11
2462#define MC_O1 12
2463#define MC_O2 13
2464#define MC_O3 14
2465#define MC_O4 15
2466#define MC_O5 16
2467#define MC_O6 17
2468#define MC_O7 18
2469#define MC_NGREG 19
2470
Anthony Liguoric227f092009-10-01 16:12:16 -05002471typedef abi_ulong target_mc_greg_t;
2472typedef target_mc_greg_t target_mc_gregset_t[MC_NGREG];
blueswir15bfb56b2007-10-05 17:01:51 +00002473
2474struct target_mc_fq {
blueswir1992f48a2007-10-14 16:27:31 +00002475 abi_ulong *mcfq_addr;
blueswir15bfb56b2007-10-05 17:01:51 +00002476 uint32_t mcfq_insn;
2477};
2478
2479struct target_mc_fpu {
2480 union {
2481 uint32_t sregs[32];
2482 uint64_t dregs[32];
2483 //uint128_t qregs[16];
2484 } mcfpu_fregs;
blueswir1992f48a2007-10-14 16:27:31 +00002485 abi_ulong mcfpu_fsr;
2486 abi_ulong mcfpu_fprs;
2487 abi_ulong mcfpu_gsr;
blueswir15bfb56b2007-10-05 17:01:51 +00002488 struct target_mc_fq *mcfpu_fq;
2489 unsigned char mcfpu_qcnt;
2490 unsigned char mcfpu_qentsz;
2491 unsigned char mcfpu_enab;
2492};
Anthony Liguoric227f092009-10-01 16:12:16 -05002493typedef struct target_mc_fpu target_mc_fpu_t;
blueswir15bfb56b2007-10-05 17:01:51 +00002494
2495typedef struct {
Anthony Liguoric227f092009-10-01 16:12:16 -05002496 target_mc_gregset_t mc_gregs;
2497 target_mc_greg_t mc_fp;
2498 target_mc_greg_t mc_i7;
2499 target_mc_fpu_t mc_fpregs;
2500} target_mcontext_t;
blueswir15bfb56b2007-10-05 17:01:51 +00002501
2502struct target_ucontext {
Aurelien Jarno60e99242010-03-29 02:12:51 +02002503 struct target_ucontext *tuc_link;
2504 abi_ulong tuc_flags;
2505 target_sigset_t tuc_sigmask;
2506 target_mcontext_t tuc_mcontext;
blueswir15bfb56b2007-10-05 17:01:51 +00002507};
2508
2509/* A V9 register window */
2510struct target_reg_window {
blueswir1992f48a2007-10-14 16:27:31 +00002511 abi_ulong locals[8];
2512 abi_ulong ins[8];
blueswir15bfb56b2007-10-05 17:01:51 +00002513};
2514
2515#define TARGET_STACK_BIAS 2047
2516
2517/* {set, get}context() needed for 64-bit SparcLinux userland. */
2518void sparc64_set_context(CPUSPARCState *env)
2519{
bellard459a4012007-11-11 19:45:10 +00002520 abi_ulong ucp_addr;
2521 struct target_ucontext *ucp;
Anthony Liguoric227f092009-10-01 16:12:16 -05002522 target_mc_gregset_t *grp;
blueswir1992f48a2007-10-14 16:27:31 +00002523 abi_ulong pc, npc, tstate;
bellard459a4012007-11-11 19:45:10 +00002524 abi_ulong fp, i7, w_addr;
blueswir15bfb56b2007-10-05 17:01:51 +00002525 unsigned int i;
blueswir15bfb56b2007-10-05 17:01:51 +00002526
bellard459a4012007-11-11 19:45:10 +00002527 ucp_addr = env->regwptr[UREG_I0];
2528 if (!lock_user_struct(VERIFY_READ, ucp, ucp_addr, 1))
2529 goto do_sigsegv;
Aurelien Jarno60e99242010-03-29 02:12:51 +02002530 grp = &ucp->tuc_mcontext.mc_gregs;
Riku Voipio1d8b5122014-04-23 10:26:05 +03002531 __get_user(pc, &((*grp)[MC_PC]));
2532 __get_user(npc, &((*grp)[MC_NPC]));
Riku Voipiobe3ef5c2014-04-23 14:02:36 +03002533 if ((pc | npc) & 3)
blueswir15bfb56b2007-10-05 17:01:51 +00002534 goto do_sigsegv;
2535 if (env->regwptr[UREG_I1]) {
Anthony Liguoric227f092009-10-01 16:12:16 -05002536 target_sigset_t target_set;
blueswir15bfb56b2007-10-05 17:01:51 +00002537 sigset_t set;
2538
2539 if (TARGET_NSIG_WORDS == 1) {
Riku Voipiobe3ef5c2014-04-23 14:02:36 +03002540 __get_user(target_set.sig[0], &ucp->tuc_sigmask.sig[0]);
blueswir15bfb56b2007-10-05 17:01:51 +00002541 } else {
bellard459a4012007-11-11 19:45:10 +00002542 abi_ulong *src, *dst;
Aurelien Jarno60e99242010-03-29 02:12:51 +02002543 src = ucp->tuc_sigmask.sig;
bellard459a4012007-11-11 19:45:10 +00002544 dst = target_set.sig;
Stefan Weil0d9e61c2013-12-07 14:48:08 +01002545 for (i = 0; i < TARGET_NSIG_WORDS; i++, dst++, src++) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03002546 __get_user(*dst, src);
Stefan Weil0d9e61c2013-12-07 14:48:08 +01002547 }
blueswir15bfb56b2007-10-05 17:01:51 +00002548 }
2549 target_to_host_sigset_internal(&set, &target_set);
Alex Barcelo1c275922014-03-14 14:36:55 +00002550 do_sigprocmask(SIG_SETMASK, &set, NULL);
blueswir15bfb56b2007-10-05 17:01:51 +00002551 }
2552 env->pc = pc;
2553 env->npc = npc;
Riku Voipio1d8b5122014-04-23 10:26:05 +03002554 __get_user(env->y, &((*grp)[MC_Y]));
2555 __get_user(tstate, &((*grp)[MC_TSTATE]));
blueswir15bfb56b2007-10-05 17:01:51 +00002556 env->asi = (tstate >> 24) & 0xff;
Blue Swirl5a834bb2010-05-09 20:19:04 +00002557 cpu_put_ccr(env, tstate >> 32);
2558 cpu_put_cwp64(env, tstate & 0x1f);
Riku Voipio1d8b5122014-04-23 10:26:05 +03002559 __get_user(env->gregs[1], (&(*grp)[MC_G1]));
2560 __get_user(env->gregs[2], (&(*grp)[MC_G2]));
2561 __get_user(env->gregs[3], (&(*grp)[MC_G3]));
2562 __get_user(env->gregs[4], (&(*grp)[MC_G4]));
2563 __get_user(env->gregs[5], (&(*grp)[MC_G5]));
2564 __get_user(env->gregs[6], (&(*grp)[MC_G6]));
2565 __get_user(env->gregs[7], (&(*grp)[MC_G7]));
2566 __get_user(env->regwptr[UREG_I0], (&(*grp)[MC_O0]));
2567 __get_user(env->regwptr[UREG_I1], (&(*grp)[MC_O1]));
2568 __get_user(env->regwptr[UREG_I2], (&(*grp)[MC_O2]));
2569 __get_user(env->regwptr[UREG_I3], (&(*grp)[MC_O3]));
2570 __get_user(env->regwptr[UREG_I4], (&(*grp)[MC_O4]));
2571 __get_user(env->regwptr[UREG_I5], (&(*grp)[MC_O5]));
2572 __get_user(env->regwptr[UREG_I6], (&(*grp)[MC_O6]));
2573 __get_user(env->regwptr[UREG_I7], (&(*grp)[MC_O7]));
blueswir15bfb56b2007-10-05 17:01:51 +00002574
Riku Voipio1d8b5122014-04-23 10:26:05 +03002575 __get_user(fp, &(ucp->tuc_mcontext.mc_fp));
2576 __get_user(i7, &(ucp->tuc_mcontext.mc_i7));
blueswir15bfb56b2007-10-05 17:01:51 +00002577
bellard459a4012007-11-11 19:45:10 +00002578 w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
2579 if (put_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]),
2580 abi_ulong) != 0)
2581 goto do_sigsegv;
2582 if (put_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]),
2583 abi_ulong) != 0)
2584 goto do_sigsegv;
Peter Maydellc7b016b2011-06-16 17:37:15 +01002585 /* FIXME this does not match how the kernel handles the FPU in
2586 * its sparc64_set_context implementation. In particular the FPU
2587 * is only restored if fenab is non-zero in:
2588 * __get_user(fenab, &(ucp->tuc_mcontext.mc_fpregs.mcfpu_enab));
2589 */
Riku Voipiobe3ef5c2014-04-23 14:02:36 +03002590 __get_user(env->fprs, &(ucp->tuc_mcontext.mc_fpregs.mcfpu_fprs));
bellard459a4012007-11-11 19:45:10 +00002591 {
Richard Henderson30038fd2011-10-17 10:42:49 -07002592 uint32_t *src = ucp->tuc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2593 for (i = 0; i < 64; i++, src++) {
2594 if (i & 1) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03002595 __get_user(env->fpr[i/2].l.lower, src);
Richard Henderson30038fd2011-10-17 10:42:49 -07002596 } else {
Riku Voipio1d8b5122014-04-23 10:26:05 +03002597 __get_user(env->fpr[i/2].l.upper, src);
Richard Henderson30038fd2011-10-17 10:42:49 -07002598 }
2599 }
bellard459a4012007-11-11 19:45:10 +00002600 }
Riku Voipio1d8b5122014-04-23 10:26:05 +03002601 __get_user(env->fsr,
2602 &(ucp->tuc_mcontext.mc_fpregs.mcfpu_fsr));
2603 __get_user(env->gsr,
2604 &(ucp->tuc_mcontext.mc_fpregs.mcfpu_gsr));
bellard459a4012007-11-11 19:45:10 +00002605 unlock_user_struct(ucp, ucp_addr, 0);
blueswir15bfb56b2007-10-05 17:01:51 +00002606 return;
2607 do_sigsegv:
bellard459a4012007-11-11 19:45:10 +00002608 unlock_user_struct(ucp, ucp_addr, 0);
Riku Voipio66393fb2009-12-04 15:16:32 +02002609 force_sig(TARGET_SIGSEGV);
blueswir15bfb56b2007-10-05 17:01:51 +00002610}
2611
2612void sparc64_get_context(CPUSPARCState *env)
2613{
bellard459a4012007-11-11 19:45:10 +00002614 abi_ulong ucp_addr;
2615 struct target_ucontext *ucp;
Anthony Liguoric227f092009-10-01 16:12:16 -05002616 target_mc_gregset_t *grp;
2617 target_mcontext_t *mcp;
bellard459a4012007-11-11 19:45:10 +00002618 abi_ulong fp, i7, w_addr;
blueswir15bfb56b2007-10-05 17:01:51 +00002619 int err;
2620 unsigned int i;
Anthony Liguoric227f092009-10-01 16:12:16 -05002621 target_sigset_t target_set;
blueswir15bfb56b2007-10-05 17:01:51 +00002622 sigset_t set;
2623
bellard459a4012007-11-11 19:45:10 +00002624 ucp_addr = env->regwptr[UREG_I0];
2625 if (!lock_user_struct(VERIFY_WRITE, ucp, ucp_addr, 0))
2626 goto do_sigsegv;
2627
Aurelien Jarno60e99242010-03-29 02:12:51 +02002628 mcp = &ucp->tuc_mcontext;
blueswir15bfb56b2007-10-05 17:01:51 +00002629 grp = &mcp->mc_gregs;
2630
2631 /* Skip over the trap instruction, first. */
2632 env->pc = env->npc;
2633 env->npc += 4;
2634
2635 err = 0;
2636
Alex Barcelo1c275922014-03-14 14:36:55 +00002637 do_sigprocmask(0, NULL, &set);
blueswir15bfb56b2007-10-05 17:01:51 +00002638 host_to_target_sigset_internal(&target_set, &set);
bellard459a4012007-11-11 19:45:10 +00002639 if (TARGET_NSIG_WORDS == 1) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03002640 __put_user(target_set.sig[0],
2641 (abi_ulong *)&ucp->tuc_sigmask);
bellard459a4012007-11-11 19:45:10 +00002642 } else {
2643 abi_ulong *src, *dst;
2644 src = target_set.sig;
Aurelien Jarno60e99242010-03-29 02:12:51 +02002645 dst = ucp->tuc_sigmask.sig;
Stefan Weil0d9e61c2013-12-07 14:48:08 +01002646 for (i = 0; i < TARGET_NSIG_WORDS; i++, dst++, src++) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03002647 __put_user(*src, dst);
Stefan Weil0d9e61c2013-12-07 14:48:08 +01002648 }
blueswir15bfb56b2007-10-05 17:01:51 +00002649 if (err)
2650 goto do_sigsegv;
2651 }
2652
bellard459a4012007-11-11 19:45:10 +00002653 /* XXX: tstate must be saved properly */
Riku Voipio1d8b5122014-04-23 10:26:05 +03002654 // __put_user(env->tstate, &((*grp)[MC_TSTATE]));
2655 __put_user(env->pc, &((*grp)[MC_PC]));
2656 __put_user(env->npc, &((*grp)[MC_NPC]));
2657 __put_user(env->y, &((*grp)[MC_Y]));
2658 __put_user(env->gregs[1], &((*grp)[MC_G1]));
2659 __put_user(env->gregs[2], &((*grp)[MC_G2]));
2660 __put_user(env->gregs[3], &((*grp)[MC_G3]));
2661 __put_user(env->gregs[4], &((*grp)[MC_G4]));
2662 __put_user(env->gregs[5], &((*grp)[MC_G5]));
2663 __put_user(env->gregs[6], &((*grp)[MC_G6]));
2664 __put_user(env->gregs[7], &((*grp)[MC_G7]));
2665 __put_user(env->regwptr[UREG_I0], &((*grp)[MC_O0]));
2666 __put_user(env->regwptr[UREG_I1], &((*grp)[MC_O1]));
2667 __put_user(env->regwptr[UREG_I2], &((*grp)[MC_O2]));
2668 __put_user(env->regwptr[UREG_I3], &((*grp)[MC_O3]));
2669 __put_user(env->regwptr[UREG_I4], &((*grp)[MC_O4]));
2670 __put_user(env->regwptr[UREG_I5], &((*grp)[MC_O5]));
2671 __put_user(env->regwptr[UREG_I6], &((*grp)[MC_O6]));
2672 __put_user(env->regwptr[UREG_I7], &((*grp)[MC_O7]));
blueswir15bfb56b2007-10-05 17:01:51 +00002673
bellard459a4012007-11-11 19:45:10 +00002674 w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
2675 fp = i7 = 0;
2676 if (get_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]),
2677 abi_ulong) != 0)
2678 goto do_sigsegv;
2679 if (get_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]),
2680 abi_ulong) != 0)
2681 goto do_sigsegv;
Riku Voipio1d8b5122014-04-23 10:26:05 +03002682 __put_user(fp, &(mcp->mc_fp));
2683 __put_user(i7, &(mcp->mc_i7));
blueswir15bfb56b2007-10-05 17:01:51 +00002684
bellard459a4012007-11-11 19:45:10 +00002685 {
Richard Henderson30038fd2011-10-17 10:42:49 -07002686 uint32_t *dst = ucp->tuc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2687 for (i = 0; i < 64; i++, dst++) {
2688 if (i & 1) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03002689 __put_user(env->fpr[i/2].l.lower, dst);
Richard Henderson30038fd2011-10-17 10:42:49 -07002690 } else {
Riku Voipio1d8b5122014-04-23 10:26:05 +03002691 __put_user(env->fpr[i/2].l.upper, dst);
Richard Henderson30038fd2011-10-17 10:42:49 -07002692 }
2693 }
bellard459a4012007-11-11 19:45:10 +00002694 }
Riku Voipio1d8b5122014-04-23 10:26:05 +03002695 __put_user(env->fsr, &(mcp->mc_fpregs.mcfpu_fsr));
2696 __put_user(env->gsr, &(mcp->mc_fpregs.mcfpu_gsr));
2697 __put_user(env->fprs, &(mcp->mc_fpregs.mcfpu_fprs));
blueswir15bfb56b2007-10-05 17:01:51 +00002698
2699 if (err)
2700 goto do_sigsegv;
bellard459a4012007-11-11 19:45:10 +00002701 unlock_user_struct(ucp, ucp_addr, 1);
blueswir15bfb56b2007-10-05 17:01:51 +00002702 return;
2703 do_sigsegv:
bellard459a4012007-11-11 19:45:10 +00002704 unlock_user_struct(ucp, ucp_addr, 1);
Riku Voipio66393fb2009-12-04 15:16:32 +02002705 force_sig(TARGET_SIGSEGV);
blueswir15bfb56b2007-10-05 17:01:51 +00002706}
2707#endif
Richard Hendersonff970902013-02-10 10:30:42 -08002708#elif defined(TARGET_MIPS) || defined(TARGET_MIPS64)
bellard106ec872006-06-27 21:08:10 +00002709
Richard Hendersonff970902013-02-10 10:30:42 -08002710# if defined(TARGET_ABI_MIPSO32)
bellard106ec872006-06-27 21:08:10 +00002711struct target_sigcontext {
2712 uint32_t sc_regmask; /* Unused */
2713 uint32_t sc_status;
2714 uint64_t sc_pc;
2715 uint64_t sc_regs[32];
2716 uint64_t sc_fpregs[32];
2717 uint32_t sc_ownedfp; /* Unused */
2718 uint32_t sc_fpc_csr;
2719 uint32_t sc_fpc_eir; /* Unused */
2720 uint32_t sc_used_math;
2721 uint32_t sc_dsp; /* dsp status, was sc_ssflags */
Paul Brook94c54952009-07-09 18:40:15 +01002722 uint32_t pad0;
bellard106ec872006-06-27 21:08:10 +00002723 uint64_t sc_mdhi;
2724 uint64_t sc_mdlo;
2725 target_ulong sc_hi1; /* Was sc_cause */
2726 target_ulong sc_lo1; /* Was sc_badvaddr */
2727 target_ulong sc_hi2; /* Was sc_sigset[4] */
2728 target_ulong sc_lo2;
2729 target_ulong sc_hi3;
2730 target_ulong sc_lo3;
2731};
Richard Hendersonff970902013-02-10 10:30:42 -08002732# else /* N32 || N64 */
2733struct target_sigcontext {
2734 uint64_t sc_regs[32];
2735 uint64_t sc_fpregs[32];
2736 uint64_t sc_mdhi;
2737 uint64_t sc_hi1;
2738 uint64_t sc_hi2;
2739 uint64_t sc_hi3;
2740 uint64_t sc_mdlo;
2741 uint64_t sc_lo1;
2742 uint64_t sc_lo2;
2743 uint64_t sc_lo3;
2744 uint64_t sc_pc;
2745 uint32_t sc_fpc_csr;
2746 uint32_t sc_used_math;
2747 uint32_t sc_dsp;
2748 uint32_t sc_reserved;
2749};
2750# endif /* O32 */
bellard106ec872006-06-27 21:08:10 +00002751
2752struct sigframe {
2753 uint32_t sf_ass[4]; /* argument save space for o32 */
2754 uint32_t sf_code[2]; /* signal trampoline */
2755 struct target_sigcontext sf_sc;
Anthony Liguoric227f092009-10-01 16:12:16 -05002756 target_sigset_t sf_mask;
bellard106ec872006-06-27 21:08:10 +00002757};
2758
pbrook0b1bcb02009-04-21 01:41:10 +00002759struct target_ucontext {
Aurelien Jarno60e99242010-03-29 02:12:51 +02002760 target_ulong tuc_flags;
2761 target_ulong tuc_link;
2762 target_stack_t tuc_stack;
Paul Brook94c54952009-07-09 18:40:15 +01002763 target_ulong pad0;
Aurelien Jarno60e99242010-03-29 02:12:51 +02002764 struct target_sigcontext tuc_mcontext;
2765 target_sigset_t tuc_sigmask;
pbrook0b1bcb02009-04-21 01:41:10 +00002766};
2767
2768struct target_rt_sigframe {
2769 uint32_t rs_ass[4]; /* argument save space for o32 */
2770 uint32_t rs_code[2]; /* signal trampoline */
2771 struct target_siginfo rs_info;
2772 struct target_ucontext rs_uc;
2773};
2774
bellard106ec872006-06-27 21:08:10 +00002775/* Install trampoline to jump back from signal handler */
2776static inline int install_sigtramp(unsigned int *tramp, unsigned int syscall)
2777{
Richard Henderson084d0492013-02-10 10:30:44 -08002778 int err = 0;
bellard106ec872006-06-27 21:08:10 +00002779
2780 /*
Richard Henderson084d0492013-02-10 10:30:44 -08002781 * Set up the return code ...
2782 *
2783 * li v0, __NR__foo_sigreturn
2784 * syscall
2785 */
bellard106ec872006-06-27 21:08:10 +00002786
Riku Voipio1d8b5122014-04-23 10:26:05 +03002787 __put_user(0x24020000 + syscall, tramp + 0);
2788 __put_user(0x0000000c , tramp + 1);
bellard106ec872006-06-27 21:08:10 +00002789 return err;
2790}
2791
Riku Voipio41ecc722014-04-23 11:01:00 +03002792static inline void setup_sigcontext(CPUMIPSState *regs,
2793 struct target_sigcontext *sc)
bellard106ec872006-06-27 21:08:10 +00002794{
Richard Henderson084d0492013-02-10 10:30:44 -08002795 int i;
bellard106ec872006-06-27 21:08:10 +00002796
Riku Voipio1d8b5122014-04-23 10:26:05 +03002797 __put_user(exception_resume_pc(regs), &sc->sc_pc);
Kwok Cheung Yeung1239b472013-05-17 14:51:21 -07002798 regs->hflags &= ~MIPS_HFLAG_BMASK;
bellard106ec872006-06-27 21:08:10 +00002799
Richard Henderson084d0492013-02-10 10:30:44 -08002800 __put_user(0, &sc->sc_regs[0]);
2801 for (i = 1; i < 32; ++i) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03002802 __put_user(regs->active_tc.gpr[i], &sc->sc_regs[i]);
Richard Henderson084d0492013-02-10 10:30:44 -08002803 }
bellard106ec872006-06-27 21:08:10 +00002804
Riku Voipio1d8b5122014-04-23 10:26:05 +03002805 __put_user(regs->active_tc.HI[0], &sc->sc_mdhi);
2806 __put_user(regs->active_tc.LO[0], &sc->sc_mdlo);
bellard106ec872006-06-27 21:08:10 +00002807
Richard Henderson084d0492013-02-10 10:30:44 -08002808 /* Rather than checking for dsp existence, always copy. The storage
2809 would just be garbage otherwise. */
Riku Voipio1d8b5122014-04-23 10:26:05 +03002810 __put_user(regs->active_tc.HI[1], &sc->sc_hi1);
2811 __put_user(regs->active_tc.HI[2], &sc->sc_hi2);
2812 __put_user(regs->active_tc.HI[3], &sc->sc_hi3);
2813 __put_user(regs->active_tc.LO[1], &sc->sc_lo1);
2814 __put_user(regs->active_tc.LO[2], &sc->sc_lo2);
2815 __put_user(regs->active_tc.LO[3], &sc->sc_lo3);
Richard Henderson084d0492013-02-10 10:30:44 -08002816 {
2817 uint32_t dsp = cpu_rddsp(0x3ff, regs);
Riku Voipio1d8b5122014-04-23 10:26:05 +03002818 __put_user(dsp, &sc->sc_dsp);
bellard106ec872006-06-27 21:08:10 +00002819 }
Richard Henderson084d0492013-02-10 10:30:44 -08002820
Riku Voipio1d8b5122014-04-23 10:26:05 +03002821 __put_user(1, &sc->sc_used_math);
Richard Henderson084d0492013-02-10 10:30:44 -08002822
2823 for (i = 0; i < 32; ++i) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03002824 __put_user(regs->active_fpu.fpr[i].d, &sc->sc_fpregs[i]);
bellard106ec872006-06-27 21:08:10 +00002825 }
bellard106ec872006-06-27 21:08:10 +00002826}
2827
Riku Voipio016d2e12014-04-23 11:19:48 +03002828static inline void
Andreas Färber05390242012-02-25 03:37:53 +01002829restore_sigcontext(CPUMIPSState *regs, struct target_sigcontext *sc)
bellard106ec872006-06-27 21:08:10 +00002830{
Richard Henderson084d0492013-02-10 10:30:44 -08002831 int i;
bellard106ec872006-06-27 21:08:10 +00002832
Riku Voipio1d8b5122014-04-23 10:26:05 +03002833 __get_user(regs->CP0_EPC, &sc->sc_pc);
bellard106ec872006-06-27 21:08:10 +00002834
Riku Voipio1d8b5122014-04-23 10:26:05 +03002835 __get_user(regs->active_tc.HI[0], &sc->sc_mdhi);
2836 __get_user(regs->active_tc.LO[0], &sc->sc_mdlo);
bellard106ec872006-06-27 21:08:10 +00002837
Richard Henderson084d0492013-02-10 10:30:44 -08002838 for (i = 1; i < 32; ++i) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03002839 __get_user(regs->active_tc.gpr[i], &sc->sc_regs[i]);
bellard106ec872006-06-27 21:08:10 +00002840 }
2841
Riku Voipio1d8b5122014-04-23 10:26:05 +03002842 __get_user(regs->active_tc.HI[1], &sc->sc_hi1);
2843 __get_user(regs->active_tc.HI[2], &sc->sc_hi2);
2844 __get_user(regs->active_tc.HI[3], &sc->sc_hi3);
2845 __get_user(regs->active_tc.LO[1], &sc->sc_lo1);
2846 __get_user(regs->active_tc.LO[2], &sc->sc_lo2);
2847 __get_user(regs->active_tc.LO[3], &sc->sc_lo3);
Richard Henderson084d0492013-02-10 10:30:44 -08002848 {
2849 uint32_t dsp;
Riku Voipio1d8b5122014-04-23 10:26:05 +03002850 __get_user(dsp, &sc->sc_dsp);
Richard Henderson084d0492013-02-10 10:30:44 -08002851 cpu_wrdsp(dsp, 0x3ff, regs);
2852 }
2853
2854 for (i = 0; i < 32; ++i) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03002855 __get_user(regs->active_fpu.fpr[i].d, &sc->sc_fpregs[i]);
Richard Henderson084d0492013-02-10 10:30:44 -08002856 }
bellard106ec872006-06-27 21:08:10 +00002857}
Richard Hendersonff970902013-02-10 10:30:42 -08002858
bellard106ec872006-06-27 21:08:10 +00002859/*
2860 * Determine which stack to use..
2861 */
bellard579a97f2007-11-11 14:26:47 +00002862static inline abi_ulong
Andreas Färber05390242012-02-25 03:37:53 +01002863get_sigframe(struct target_sigaction *ka, CPUMIPSState *regs, size_t frame_size)
bellard106ec872006-06-27 21:08:10 +00002864{
2865 unsigned long sp;
2866
2867 /* Default to using normal stack */
thsb5dc7732008-06-27 10:02:35 +00002868 sp = regs->active_tc.gpr[29];
bellard106ec872006-06-27 21:08:10 +00002869
2870 /*
Stefan Weil93148aa2012-02-26 18:46:12 +01002871 * FPU emulator may have its own trampoline active just
bellard106ec872006-06-27 21:08:10 +00002872 * above the user stack, 16-bytes before the next lowest
2873 * 16 byte boundary. Try to avoid trashing it.
2874 */
2875 sp -= 32;
2876
bellard106ec872006-06-27 21:08:10 +00002877 /* This is the X/Open sanctioned signal stack switching. */
pbrook624f7972008-05-31 16:11:38 +00002878 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) {
thsa04e1342007-09-27 13:57:58 +00002879 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
2880 }
bellard106ec872006-06-27 21:08:10 +00002881
bellard579a97f2007-11-11 14:26:47 +00002882 return (sp - frame_size) & ~7;
bellard106ec872006-06-27 21:08:10 +00002883}
2884
Kwok Cheung Yeungea3164a2013-05-17 14:51:20 -07002885static void mips_set_hflags_isa_mode_from_pc(CPUMIPSState *env)
2886{
2887 if (env->insn_flags & (ASE_MIPS16 | ASE_MICROMIPS)) {
2888 env->hflags &= ~MIPS_HFLAG_M16;
2889 env->hflags |= (env->active_tc.PC & 1) << MIPS_HFLAG_M16_SHIFT;
2890 env->active_tc.PC &= ~(target_ulong) 1;
2891 }
2892}
2893
Richard Hendersonff970902013-02-10 10:30:42 -08002894# if defined(TARGET_ABI_MIPSO32)
bellard579a97f2007-11-11 14:26:47 +00002895/* compare linux/arch/mips/kernel/signal.c:setup_frame() */
pbrook624f7972008-05-31 16:11:38 +00002896static void setup_frame(int sig, struct target_sigaction * ka,
Andreas Färber05390242012-02-25 03:37:53 +01002897 target_sigset_t *set, CPUMIPSState *regs)
bellard106ec872006-06-27 21:08:10 +00002898{
2899 struct sigframe *frame;
bellard579a97f2007-11-11 14:26:47 +00002900 abi_ulong frame_addr;
bellard106ec872006-06-27 21:08:10 +00002901 int i;
2902
bellard579a97f2007-11-11 14:26:47 +00002903 frame_addr = get_sigframe(ka, regs, sizeof(*frame));
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01002904 trace_user_setup_frame(regs, frame_addr);
bellard579a97f2007-11-11 14:26:47 +00002905 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
bellard106ec872006-06-27 21:08:10 +00002906 goto give_sigsegv;
2907
2908 install_sigtramp(frame->sf_code, TARGET_NR_sigreturn);
2909
Riku Voipio41ecc722014-04-23 11:01:00 +03002910 setup_sigcontext(regs, &frame->sf_sc);
bellard106ec872006-06-27 21:08:10 +00002911
2912 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
Riku Voipio0188fad2014-04-23 13:34:15 +03002913 __put_user(set->sig[i], &frame->sf_mask.sig[i]);
bellard106ec872006-06-27 21:08:10 +00002914 }
2915
2916 /*
2917 * Arguments to signal handler:
2918 *
2919 * a0 = signal number
2920 * a1 = 0 (should be cause)
2921 * a2 = pointer to struct sigcontext
2922 *
2923 * $25 and PC point to the signal handler, $29 points to the
2924 * struct sigframe.
2925 */
thsb5dc7732008-06-27 10:02:35 +00002926 regs->active_tc.gpr[ 4] = sig;
2927 regs->active_tc.gpr[ 5] = 0;
2928 regs->active_tc.gpr[ 6] = frame_addr + offsetof(struct sigframe, sf_sc);
2929 regs->active_tc.gpr[29] = frame_addr;
2930 regs->active_tc.gpr[31] = frame_addr + offsetof(struct sigframe, sf_code);
bellard106ec872006-06-27 21:08:10 +00002931 /* The original kernel code sets CP0_EPC to the handler
2932 * since it returns to userland using eret
2933 * we cannot do this here, and we must set PC directly */
thsb5dc7732008-06-27 10:02:35 +00002934 regs->active_tc.PC = regs->active_tc.gpr[25] = ka->_sa_handler;
Kwok Cheung Yeungea3164a2013-05-17 14:51:20 -07002935 mips_set_hflags_isa_mode_from_pc(regs);
bellard579a97f2007-11-11 14:26:47 +00002936 unlock_user_struct(frame, frame_addr, 1);
bellard106ec872006-06-27 21:08:10 +00002937 return;
2938
2939give_sigsegv:
2940 force_sig(TARGET_SIGSEGV/*, current*/);
bellard106ec872006-06-27 21:08:10 +00002941}
2942
Andreas Färber05390242012-02-25 03:37:53 +01002943long do_sigreturn(CPUMIPSState *regs)
bellard106ec872006-06-27 21:08:10 +00002944{
ths388bb212007-05-13 13:58:00 +00002945 struct sigframe *frame;
bellard579a97f2007-11-11 14:26:47 +00002946 abi_ulong frame_addr;
ths388bb212007-05-13 13:58:00 +00002947 sigset_t blocked;
Anthony Liguoric227f092009-10-01 16:12:16 -05002948 target_sigset_t target_set;
ths388bb212007-05-13 13:58:00 +00002949 int i;
bellard106ec872006-06-27 21:08:10 +00002950
thsb5dc7732008-06-27 10:02:35 +00002951 frame_addr = regs->active_tc.gpr[29];
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01002952 trace_user_do_sigreturn(regs, frame_addr);
bellard579a97f2007-11-11 14:26:47 +00002953 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
bellard106ec872006-06-27 21:08:10 +00002954 goto badframe;
2955
ths388bb212007-05-13 13:58:00 +00002956 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
Riku Voipiof5f601a2014-04-23 13:00:17 +03002957 __get_user(target_set.sig[i], &frame->sf_mask.sig[i]);
ths388bb212007-05-13 13:58:00 +00002958 }
bellard106ec872006-06-27 21:08:10 +00002959
ths388bb212007-05-13 13:58:00 +00002960 target_to_host_sigset_internal(&blocked, &target_set);
Alex Barcelo1c275922014-03-14 14:36:55 +00002961 do_sigprocmask(SIG_SETMASK, &blocked, NULL);
bellard106ec872006-06-27 21:08:10 +00002962
Riku Voipio016d2e12014-04-23 11:19:48 +03002963 restore_sigcontext(regs, &frame->sf_sc);
bellard106ec872006-06-27 21:08:10 +00002964
2965#if 0
ths388bb212007-05-13 13:58:00 +00002966 /*
2967 * Don't let your children do this ...
2968 */
2969 __asm__ __volatile__(
bellard106ec872006-06-27 21:08:10 +00002970 "move\t$29, %0\n\t"
2971 "j\tsyscall_exit"
2972 :/* no outputs */
2973 :"r" (&regs));
ths388bb212007-05-13 13:58:00 +00002974 /* Unreached */
bellard106ec872006-06-27 21:08:10 +00002975#endif
ths3b46e622007-09-17 08:09:54 +00002976
thsb5dc7732008-06-27 10:02:35 +00002977 regs->active_tc.PC = regs->CP0_EPC;
Kwok Cheung Yeungea3164a2013-05-17 14:51:20 -07002978 mips_set_hflags_isa_mode_from_pc(regs);
ths388bb212007-05-13 13:58:00 +00002979 /* I am not sure this is right, but it seems to work
bellard106ec872006-06-27 21:08:10 +00002980 * maybe a problem with nested signals ? */
2981 regs->CP0_EPC = 0;
pbrook0b1bcb02009-04-21 01:41:10 +00002982 return -TARGET_QEMU_ESIGRETURN;
bellard106ec872006-06-27 21:08:10 +00002983
2984badframe:
ths388bb212007-05-13 13:58:00 +00002985 force_sig(TARGET_SIGSEGV/*, current*/);
2986 return 0;
bellard106ec872006-06-27 21:08:10 +00002987}
Richard Hendersonff970902013-02-10 10:30:42 -08002988# endif /* O32 */
bellard106ec872006-06-27 21:08:10 +00002989
pbrook624f7972008-05-31 16:11:38 +00002990static void setup_rt_frame(int sig, struct target_sigaction *ka,
Anthony Liguoric227f092009-10-01 16:12:16 -05002991 target_siginfo_t *info,
Andreas Färber05390242012-02-25 03:37:53 +01002992 target_sigset_t *set, CPUMIPSState *env)
bellard106ec872006-06-27 21:08:10 +00002993{
pbrook0b1bcb02009-04-21 01:41:10 +00002994 struct target_rt_sigframe *frame;
2995 abi_ulong frame_addr;
2996 int i;
2997
2998 frame_addr = get_sigframe(ka, env, sizeof(*frame));
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01002999 trace_user_setup_rt_frame(env, frame_addr);
pbrook0b1bcb02009-04-21 01:41:10 +00003000 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3001 goto give_sigsegv;
3002
3003 install_sigtramp(frame->rs_code, TARGET_NR_rt_sigreturn);
3004
Peter Maydellf6c7a052015-01-08 12:19:48 +00003005 tswap_siginfo(&frame->rs_info, info);
pbrook0b1bcb02009-04-21 01:41:10 +00003006
Aurelien Jarno60e99242010-03-29 02:12:51 +02003007 __put_user(0, &frame->rs_uc.tuc_flags);
3008 __put_user(0, &frame->rs_uc.tuc_link);
3009 __put_user(target_sigaltstack_used.ss_sp, &frame->rs_uc.tuc_stack.ss_sp);
3010 __put_user(target_sigaltstack_used.ss_size, &frame->rs_uc.tuc_stack.ss_size);
pbrook0b1bcb02009-04-21 01:41:10 +00003011 __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
Aurelien Jarno60e99242010-03-29 02:12:51 +02003012 &frame->rs_uc.tuc_stack.ss_flags);
pbrook0b1bcb02009-04-21 01:41:10 +00003013
Aurelien Jarno60e99242010-03-29 02:12:51 +02003014 setup_sigcontext(env, &frame->rs_uc.tuc_mcontext);
pbrook0b1bcb02009-04-21 01:41:10 +00003015
3016 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
Aurelien Jarno60e99242010-03-29 02:12:51 +02003017 __put_user(set->sig[i], &frame->rs_uc.tuc_sigmask.sig[i]);
pbrook0b1bcb02009-04-21 01:41:10 +00003018 }
3019
3020 /*
3021 * Arguments to signal handler:
3022 *
3023 * a0 = signal number
Richard W.M. Jones02d2bd52012-07-05 03:32:44 +00003024 * a1 = pointer to siginfo_t
pbrook0b1bcb02009-04-21 01:41:10 +00003025 * a2 = pointer to struct ucontext
3026 *
3027 * $25 and PC point to the signal handler, $29 points to the
3028 * struct sigframe.
3029 */
3030 env->active_tc.gpr[ 4] = sig;
3031 env->active_tc.gpr[ 5] = frame_addr
3032 + offsetof(struct target_rt_sigframe, rs_info);
3033 env->active_tc.gpr[ 6] = frame_addr
3034 + offsetof(struct target_rt_sigframe, rs_uc);
3035 env->active_tc.gpr[29] = frame_addr;
3036 env->active_tc.gpr[31] = frame_addr
3037 + offsetof(struct target_rt_sigframe, rs_code);
3038 /* The original kernel code sets CP0_EPC to the handler
3039 * since it returns to userland using eret
3040 * we cannot do this here, and we must set PC directly */
3041 env->active_tc.PC = env->active_tc.gpr[25] = ka->_sa_handler;
Kwok Cheung Yeungea3164a2013-05-17 14:51:20 -07003042 mips_set_hflags_isa_mode_from_pc(env);
pbrook0b1bcb02009-04-21 01:41:10 +00003043 unlock_user_struct(frame, frame_addr, 1);
3044 return;
3045
3046give_sigsegv:
3047 unlock_user_struct(frame, frame_addr, 1);
3048 force_sig(TARGET_SIGSEGV/*, current*/);
bellard106ec872006-06-27 21:08:10 +00003049}
3050
Andreas Färber05390242012-02-25 03:37:53 +01003051long do_rt_sigreturn(CPUMIPSState *env)
bellard106ec872006-06-27 21:08:10 +00003052{
pbrook0b1bcb02009-04-21 01:41:10 +00003053 struct target_rt_sigframe *frame;
3054 abi_ulong frame_addr;
3055 sigset_t blocked;
3056
pbrook0b1bcb02009-04-21 01:41:10 +00003057 frame_addr = env->active_tc.gpr[29];
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01003058 trace_user_do_rt_sigreturn(env, frame_addr);
pbrook0b1bcb02009-04-21 01:41:10 +00003059 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
3060 goto badframe;
3061
Aurelien Jarno60e99242010-03-29 02:12:51 +02003062 target_to_host_sigset(&blocked, &frame->rs_uc.tuc_sigmask);
Alex Barcelo1c275922014-03-14 14:36:55 +00003063 do_sigprocmask(SIG_SETMASK, &blocked, NULL);
pbrook0b1bcb02009-04-21 01:41:10 +00003064
Riku Voipio016d2e12014-04-23 11:19:48 +03003065 restore_sigcontext(env, &frame->rs_uc.tuc_mcontext);
pbrook0b1bcb02009-04-21 01:41:10 +00003066
3067 if (do_sigaltstack(frame_addr +
Aurelien Jarno60e99242010-03-29 02:12:51 +02003068 offsetof(struct target_rt_sigframe, rs_uc.tuc_stack),
pbrook0b1bcb02009-04-21 01:41:10 +00003069 0, get_sp_from_cpustate(env)) == -EFAULT)
3070 goto badframe;
3071
3072 env->active_tc.PC = env->CP0_EPC;
Kwok Cheung Yeungea3164a2013-05-17 14:51:20 -07003073 mips_set_hflags_isa_mode_from_pc(env);
pbrook0b1bcb02009-04-21 01:41:10 +00003074 /* I am not sure this is right, but it seems to work
3075 * maybe a problem with nested signals ? */
3076 env->CP0_EPC = 0;
3077 return -TARGET_QEMU_ESIGRETURN;
3078
3079badframe:
3080 force_sig(TARGET_SIGSEGV/*, current*/);
3081 return 0;
bellard106ec872006-06-27 21:08:10 +00003082}
bellard6d5e2162004-09-30 22:04:13 +00003083
thsc3b5bc82007-12-02 06:31:25 +00003084#elif defined(TARGET_SH4)
3085
3086/*
3087 * code and data structures from linux kernel:
3088 * include/asm-sh/sigcontext.h
3089 * arch/sh/kernel/signal.c
3090 */
3091
3092struct target_sigcontext {
3093 target_ulong oldmask;
3094
3095 /* CPU registers */
3096 target_ulong sc_gregs[16];
3097 target_ulong sc_pc;
3098 target_ulong sc_pr;
3099 target_ulong sc_sr;
3100 target_ulong sc_gbr;
3101 target_ulong sc_mach;
3102 target_ulong sc_macl;
3103
3104 /* FPU registers */
3105 target_ulong sc_fpregs[16];
3106 target_ulong sc_xfpregs[16];
3107 unsigned int sc_fpscr;
3108 unsigned int sc_fpul;
3109 unsigned int sc_ownedfp;
3110};
3111
3112struct target_sigframe
3113{
3114 struct target_sigcontext sc;
3115 target_ulong extramask[TARGET_NSIG_WORDS-1];
3116 uint16_t retcode[3];
3117};
3118
3119
3120struct target_ucontext {
Aurelien Jarno60e99242010-03-29 02:12:51 +02003121 target_ulong tuc_flags;
3122 struct target_ucontext *tuc_link;
3123 target_stack_t tuc_stack;
3124 struct target_sigcontext tuc_mcontext;
3125 target_sigset_t tuc_sigmask; /* mask last for extensibility */
thsc3b5bc82007-12-02 06:31:25 +00003126};
3127
3128struct target_rt_sigframe
3129{
3130 struct target_siginfo info;
3131 struct target_ucontext uc;
3132 uint16_t retcode[3];
3133};
3134
3135
3136#define MOVW(n) (0x9300|((n)-2)) /* Move mem word at PC+n to R3 */
3137#define TRAP_NOARG 0xc310 /* Syscall w/no args (NR in R3) SH3/4 */
3138
pbrook624f7972008-05-31 16:11:38 +00003139static abi_ulong get_sigframe(struct target_sigaction *ka,
thsc3b5bc82007-12-02 06:31:25 +00003140 unsigned long sp, size_t frame_size)
3141{
pbrook624f7972008-05-31 16:11:38 +00003142 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags(sp) == 0)) {
thsc3b5bc82007-12-02 06:31:25 +00003143 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
3144 }
3145
3146 return (sp - frame_size) & -8ul;
3147}
3148
Riku Voipio41ecc722014-04-23 11:01:00 +03003149static void setup_sigcontext(struct target_sigcontext *sc,
Andreas Färber05390242012-02-25 03:37:53 +01003150 CPUSH4State *regs, unsigned long mask)
thsc3b5bc82007-12-02 06:31:25 +00003151{
takasi-y@ops.dti.ne.jpd8714432010-02-18 00:46:45 +09003152 int i;
thsc3b5bc82007-12-02 06:31:25 +00003153
Riku Voipio1d8b5122014-04-23 10:26:05 +03003154#define COPY(x) __put_user(regs->x, &sc->sc_##x)
thsc3b5bc82007-12-02 06:31:25 +00003155 COPY(gregs[0]); COPY(gregs[1]);
3156 COPY(gregs[2]); COPY(gregs[3]);
3157 COPY(gregs[4]); COPY(gregs[5]);
3158 COPY(gregs[6]); COPY(gregs[7]);
3159 COPY(gregs[8]); COPY(gregs[9]);
3160 COPY(gregs[10]); COPY(gregs[11]);
3161 COPY(gregs[12]); COPY(gregs[13]);
3162 COPY(gregs[14]); COPY(gregs[15]);
3163 COPY(gbr); COPY(mach);
3164 COPY(macl); COPY(pr);
3165 COPY(sr); COPY(pc);
3166#undef COPY
3167
takasi-y@ops.dti.ne.jpd8714432010-02-18 00:46:45 +09003168 for (i=0; i<16; i++) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03003169 __put_user(regs->fregs[i], &sc->sc_fpregs[i]);
takasi-y@ops.dti.ne.jpd8714432010-02-18 00:46:45 +09003170 }
Riku Voipio1d8b5122014-04-23 10:26:05 +03003171 __put_user(regs->fpscr, &sc->sc_fpscr);
3172 __put_user(regs->fpul, &sc->sc_fpul);
thsc3b5bc82007-12-02 06:31:25 +00003173
3174 /* non-iBCS2 extensions.. */
Riku Voipio1d8b5122014-04-23 10:26:05 +03003175 __put_user(mask, &sc->oldmask);
thsc3b5bc82007-12-02 06:31:25 +00003176}
3177
Riku Voipio016d2e12014-04-23 11:19:48 +03003178static void restore_sigcontext(CPUSH4State *regs, struct target_sigcontext *sc,
takasi-y@ops.dti.ne.jpd8714432010-02-18 00:46:45 +09003179 target_ulong *r0_p)
thsc3b5bc82007-12-02 06:31:25 +00003180{
takasi-y@ops.dti.ne.jpd8714432010-02-18 00:46:45 +09003181 int i;
thsc3b5bc82007-12-02 06:31:25 +00003182
Riku Voipio1d8b5122014-04-23 10:26:05 +03003183#define COPY(x) __get_user(regs->x, &sc->sc_##x)
thsc3b5bc82007-12-02 06:31:25 +00003184 COPY(gregs[1]);
3185 COPY(gregs[2]); COPY(gregs[3]);
3186 COPY(gregs[4]); COPY(gregs[5]);
3187 COPY(gregs[6]); COPY(gregs[7]);
3188 COPY(gregs[8]); COPY(gregs[9]);
3189 COPY(gregs[10]); COPY(gregs[11]);
3190 COPY(gregs[12]); COPY(gregs[13]);
3191 COPY(gregs[14]); COPY(gregs[15]);
3192 COPY(gbr); COPY(mach);
3193 COPY(macl); COPY(pr);
3194 COPY(sr); COPY(pc);
3195#undef COPY
3196
takasi-y@ops.dti.ne.jpd8714432010-02-18 00:46:45 +09003197 for (i=0; i<16; i++) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03003198 __get_user(regs->fregs[i], &sc->sc_fpregs[i]);
takasi-y@ops.dti.ne.jpd8714432010-02-18 00:46:45 +09003199 }
Riku Voipio1d8b5122014-04-23 10:26:05 +03003200 __get_user(regs->fpscr, &sc->sc_fpscr);
3201 __get_user(regs->fpul, &sc->sc_fpul);
thsc3b5bc82007-12-02 06:31:25 +00003202
3203 regs->tra = -1; /* disable syscall checks */
Riku Voipio1d8b5122014-04-23 10:26:05 +03003204 __get_user(*r0_p, &sc->sc_gregs[0]);
thsc3b5bc82007-12-02 06:31:25 +00003205}
3206
pbrook624f7972008-05-31 16:11:38 +00003207static void setup_frame(int sig, struct target_sigaction *ka,
Andreas Färber05390242012-02-25 03:37:53 +01003208 target_sigset_t *set, CPUSH4State *regs)
thsc3b5bc82007-12-02 06:31:25 +00003209{
3210 struct target_sigframe *frame;
3211 abi_ulong frame_addr;
3212 int i;
3213 int err = 0;
thsc3b5bc82007-12-02 06:31:25 +00003214
3215 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01003216 trace_user_setup_frame(regs, frame_addr);
thsc3b5bc82007-12-02 06:31:25 +00003217 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3218 goto give_sigsegv;
3219
Riku Voipio41ecc722014-04-23 11:01:00 +03003220 setup_sigcontext(&frame->sc, regs, set->sig[0]);
thsc3b5bc82007-12-02 06:31:25 +00003221
3222 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03003223 __put_user(set->sig[i + 1], &frame->extramask[i]);
thsc3b5bc82007-12-02 06:31:25 +00003224 }
3225
3226 /* Set up to return from userspace. If provided, use a stub
3227 already in userspace. */
pbrook624f7972008-05-31 16:11:38 +00003228 if (ka->sa_flags & TARGET_SA_RESTORER) {
3229 regs->pr = (unsigned long) ka->sa_restorer;
thsc3b5bc82007-12-02 06:31:25 +00003230 } else {
3231 /* Generate return code (system call to sigreturn) */
Riku Voipio1d8b5122014-04-23 10:26:05 +03003232 __put_user(MOVW(2), &frame->retcode[0]);
3233 __put_user(TRAP_NOARG, &frame->retcode[1]);
3234 __put_user((TARGET_NR_sigreturn), &frame->retcode[2]);
thsc3b5bc82007-12-02 06:31:25 +00003235 regs->pr = (unsigned long) frame->retcode;
3236 }
3237
3238 if (err)
3239 goto give_sigsegv;
3240
3241 /* Set up registers for signal handler */
Edgar E. Iglesiascb9c6262011-08-22 18:44:58 +02003242 regs->gregs[15] = frame_addr;
Peter Maydellb6e2c932015-01-08 12:19:43 +00003243 regs->gregs[4] = sig; /* Arg for signal handler */
thsc3b5bc82007-12-02 06:31:25 +00003244 regs->gregs[5] = 0;
Edgar E. Iglesiascb9c6262011-08-22 18:44:58 +02003245 regs->gregs[6] = frame_addr += offsetof(typeof(*frame), sc);
pbrook624f7972008-05-31 16:11:38 +00003246 regs->pc = (unsigned long) ka->_sa_handler;
thsc3b5bc82007-12-02 06:31:25 +00003247
3248 unlock_user_struct(frame, frame_addr, 1);
3249 return;
3250
3251give_sigsegv:
3252 unlock_user_struct(frame, frame_addr, 1);
Riku Voipio66393fb2009-12-04 15:16:32 +02003253 force_sig(TARGET_SIGSEGV);
thsc3b5bc82007-12-02 06:31:25 +00003254}
3255
pbrook624f7972008-05-31 16:11:38 +00003256static void setup_rt_frame(int sig, struct target_sigaction *ka,
Anthony Liguoric227f092009-10-01 16:12:16 -05003257 target_siginfo_t *info,
Andreas Färber05390242012-02-25 03:37:53 +01003258 target_sigset_t *set, CPUSH4State *regs)
thsc3b5bc82007-12-02 06:31:25 +00003259{
3260 struct target_rt_sigframe *frame;
3261 abi_ulong frame_addr;
3262 int i;
3263 int err = 0;
thsc3b5bc82007-12-02 06:31:25 +00003264
3265 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01003266 trace_user_setup_rt_frame(regs, frame_addr);
thsc3b5bc82007-12-02 06:31:25 +00003267 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3268 goto give_sigsegv;
3269
Peter Maydellf6c7a052015-01-08 12:19:48 +00003270 tswap_siginfo(&frame->info, info);
thsc3b5bc82007-12-02 06:31:25 +00003271
3272 /* Create the ucontext. */
Riku Voipio1d8b5122014-04-23 10:26:05 +03003273 __put_user(0, &frame->uc.tuc_flags);
3274 __put_user(0, (unsigned long *)&frame->uc.tuc_link);
3275 __put_user((unsigned long)target_sigaltstack_used.ss_sp,
3276 &frame->uc.tuc_stack.ss_sp);
3277 __put_user(sas_ss_flags(regs->gregs[15]),
3278 &frame->uc.tuc_stack.ss_flags);
3279 __put_user(target_sigaltstack_used.ss_size,
3280 &frame->uc.tuc_stack.ss_size);
3281 setup_sigcontext(&frame->uc.tuc_mcontext,
thsc3b5bc82007-12-02 06:31:25 +00003282 regs, set->sig[0]);
3283 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03003284 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
thsc3b5bc82007-12-02 06:31:25 +00003285 }
3286
3287 /* Set up to return from userspace. If provided, use a stub
3288 already in userspace. */
pbrook624f7972008-05-31 16:11:38 +00003289 if (ka->sa_flags & TARGET_SA_RESTORER) {
3290 regs->pr = (unsigned long) ka->sa_restorer;
thsc3b5bc82007-12-02 06:31:25 +00003291 } else {
3292 /* Generate return code (system call to sigreturn) */
Riku Voipio1d8b5122014-04-23 10:26:05 +03003293 __put_user(MOVW(2), &frame->retcode[0]);
3294 __put_user(TRAP_NOARG, &frame->retcode[1]);
3295 __put_user((TARGET_NR_rt_sigreturn), &frame->retcode[2]);
thsc3b5bc82007-12-02 06:31:25 +00003296 regs->pr = (unsigned long) frame->retcode;
3297 }
3298
3299 if (err)
3300 goto give_sigsegv;
3301
3302 /* Set up registers for signal handler */
Edgar E. Iglesiascb9c6262011-08-22 18:44:58 +02003303 regs->gregs[15] = frame_addr;
Peter Maydellb6e2c932015-01-08 12:19:43 +00003304 regs->gregs[4] = sig; /* Arg for signal handler */
Edgar E. Iglesiascb9c6262011-08-22 18:44:58 +02003305 regs->gregs[5] = frame_addr + offsetof(typeof(*frame), info);
3306 regs->gregs[6] = frame_addr + offsetof(typeof(*frame), uc);
pbrook624f7972008-05-31 16:11:38 +00003307 regs->pc = (unsigned long) ka->_sa_handler;
thsc3b5bc82007-12-02 06:31:25 +00003308
3309 unlock_user_struct(frame, frame_addr, 1);
3310 return;
3311
3312give_sigsegv:
3313 unlock_user_struct(frame, frame_addr, 1);
Riku Voipio66393fb2009-12-04 15:16:32 +02003314 force_sig(TARGET_SIGSEGV);
thsc3b5bc82007-12-02 06:31:25 +00003315}
3316
Andreas Färber05390242012-02-25 03:37:53 +01003317long do_sigreturn(CPUSH4State *regs)
thsc3b5bc82007-12-02 06:31:25 +00003318{
3319 struct target_sigframe *frame;
3320 abi_ulong frame_addr;
3321 sigset_t blocked;
Anthony Liguoric227f092009-10-01 16:12:16 -05003322 target_sigset_t target_set;
takasi-y@ops.dti.ne.jpd8714432010-02-18 00:46:45 +09003323 target_ulong r0;
thsc3b5bc82007-12-02 06:31:25 +00003324 int i;
3325 int err = 0;
3326
thsc3b5bc82007-12-02 06:31:25 +00003327 frame_addr = regs->gregs[15];
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01003328 trace_user_do_sigreturn(regs, frame_addr);
thsc3b5bc82007-12-02 06:31:25 +00003329 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
3330 goto badframe;
3331
Riku Voipio1d8b5122014-04-23 10:26:05 +03003332 __get_user(target_set.sig[0], &frame->sc.oldmask);
thsc3b5bc82007-12-02 06:31:25 +00003333 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03003334 __get_user(target_set.sig[i], &frame->extramask[i - 1]);
thsc3b5bc82007-12-02 06:31:25 +00003335 }
3336
3337 if (err)
3338 goto badframe;
3339
3340 target_to_host_sigset_internal(&blocked, &target_set);
Alex Barcelo1c275922014-03-14 14:36:55 +00003341 do_sigprocmask(SIG_SETMASK, &blocked, NULL);
thsc3b5bc82007-12-02 06:31:25 +00003342
Riku Voipio016d2e12014-04-23 11:19:48 +03003343 restore_sigcontext(regs, &frame->sc, &r0);
thsc3b5bc82007-12-02 06:31:25 +00003344
3345 unlock_user_struct(frame, frame_addr, 0);
takasi-y@ops.dti.ne.jpd8714432010-02-18 00:46:45 +09003346 return r0;
thsc3b5bc82007-12-02 06:31:25 +00003347
3348badframe:
3349 unlock_user_struct(frame, frame_addr, 0);
3350 force_sig(TARGET_SIGSEGV);
3351 return 0;
3352}
3353
Andreas Färber05390242012-02-25 03:37:53 +01003354long do_rt_sigreturn(CPUSH4State *regs)
thsc3b5bc82007-12-02 06:31:25 +00003355{
3356 struct target_rt_sigframe *frame;
3357 abi_ulong frame_addr;
3358 sigset_t blocked;
takasi-y@ops.dti.ne.jpd8714432010-02-18 00:46:45 +09003359 target_ulong r0;
thsc3b5bc82007-12-02 06:31:25 +00003360
thsc3b5bc82007-12-02 06:31:25 +00003361 frame_addr = regs->gregs[15];
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01003362 trace_user_do_rt_sigreturn(regs, frame_addr);
thsc3b5bc82007-12-02 06:31:25 +00003363 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
3364 goto badframe;
3365
Aurelien Jarno60e99242010-03-29 02:12:51 +02003366 target_to_host_sigset(&blocked, &frame->uc.tuc_sigmask);
Alex Barcelo1c275922014-03-14 14:36:55 +00003367 do_sigprocmask(SIG_SETMASK, &blocked, NULL);
thsc3b5bc82007-12-02 06:31:25 +00003368
Riku Voipio016d2e12014-04-23 11:19:48 +03003369 restore_sigcontext(regs, &frame->uc.tuc_mcontext, &r0);
thsc3b5bc82007-12-02 06:31:25 +00003370
3371 if (do_sigaltstack(frame_addr +
Aurelien Jarno60e99242010-03-29 02:12:51 +02003372 offsetof(struct target_rt_sigframe, uc.tuc_stack),
thsc3b5bc82007-12-02 06:31:25 +00003373 0, get_sp_from_cpustate(regs)) == -EFAULT)
3374 goto badframe;
3375
3376 unlock_user_struct(frame, frame_addr, 0);
takasi-y@ops.dti.ne.jpd8714432010-02-18 00:46:45 +09003377 return r0;
thsc3b5bc82007-12-02 06:31:25 +00003378
3379badframe:
3380 unlock_user_struct(frame, frame_addr, 0);
3381 force_sig(TARGET_SIGSEGV);
3382 return 0;
3383}
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003384#elif defined(TARGET_MICROBLAZE)
3385
3386struct target_sigcontext {
3387 struct target_pt_regs regs; /* needs to be first */
3388 uint32_t oldmask;
3389};
3390
Edgar E. Iglesiasb2178702010-07-23 09:30:37 +02003391struct target_stack_t {
3392 abi_ulong ss_sp;
3393 int ss_flags;
3394 unsigned int ss_size;
3395};
3396
3397struct target_ucontext {
Richard Hendersonf711df62010-11-22 14:57:52 -08003398 abi_ulong tuc_flags;
3399 abi_ulong tuc_link;
3400 struct target_stack_t tuc_stack;
3401 struct target_sigcontext tuc_mcontext;
3402 uint32_t tuc_extramask[TARGET_NSIG_WORDS - 1];
Edgar E. Iglesiasb2178702010-07-23 09:30:37 +02003403};
3404
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003405/* Signal frames. */
3406struct target_signal_frame {
Edgar E. Iglesiasb2178702010-07-23 09:30:37 +02003407 struct target_ucontext uc;
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003408 uint32_t extramask[TARGET_NSIG_WORDS - 1];
3409 uint32_t tramp[2];
3410};
3411
3412struct rt_signal_frame {
Richard W.M. Jones02d2bd52012-07-05 03:32:44 +00003413 siginfo_t info;
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003414 struct ucontext uc;
3415 uint32_t tramp[2];
3416};
3417
Andreas Färber05390242012-02-25 03:37:53 +01003418static void setup_sigcontext(struct target_sigcontext *sc, CPUMBState *env)
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003419{
3420 __put_user(env->regs[0], &sc->regs.r0);
3421 __put_user(env->regs[1], &sc->regs.r1);
3422 __put_user(env->regs[2], &sc->regs.r2);
3423 __put_user(env->regs[3], &sc->regs.r3);
3424 __put_user(env->regs[4], &sc->regs.r4);
3425 __put_user(env->regs[5], &sc->regs.r5);
3426 __put_user(env->regs[6], &sc->regs.r6);
3427 __put_user(env->regs[7], &sc->regs.r7);
3428 __put_user(env->regs[8], &sc->regs.r8);
3429 __put_user(env->regs[9], &sc->regs.r9);
3430 __put_user(env->regs[10], &sc->regs.r10);
3431 __put_user(env->regs[11], &sc->regs.r11);
3432 __put_user(env->regs[12], &sc->regs.r12);
3433 __put_user(env->regs[13], &sc->regs.r13);
3434 __put_user(env->regs[14], &sc->regs.r14);
3435 __put_user(env->regs[15], &sc->regs.r15);
3436 __put_user(env->regs[16], &sc->regs.r16);
3437 __put_user(env->regs[17], &sc->regs.r17);
3438 __put_user(env->regs[18], &sc->regs.r18);
3439 __put_user(env->regs[19], &sc->regs.r19);
3440 __put_user(env->regs[20], &sc->regs.r20);
3441 __put_user(env->regs[21], &sc->regs.r21);
3442 __put_user(env->regs[22], &sc->regs.r22);
3443 __put_user(env->regs[23], &sc->regs.r23);
3444 __put_user(env->regs[24], &sc->regs.r24);
3445 __put_user(env->regs[25], &sc->regs.r25);
3446 __put_user(env->regs[26], &sc->regs.r26);
3447 __put_user(env->regs[27], &sc->regs.r27);
3448 __put_user(env->regs[28], &sc->regs.r28);
3449 __put_user(env->regs[29], &sc->regs.r29);
3450 __put_user(env->regs[30], &sc->regs.r30);
3451 __put_user(env->regs[31], &sc->regs.r31);
3452 __put_user(env->sregs[SR_PC], &sc->regs.pc);
3453}
3454
Andreas Färber05390242012-02-25 03:37:53 +01003455static void restore_sigcontext(struct target_sigcontext *sc, CPUMBState *env)
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003456{
3457 __get_user(env->regs[0], &sc->regs.r0);
3458 __get_user(env->regs[1], &sc->regs.r1);
3459 __get_user(env->regs[2], &sc->regs.r2);
3460 __get_user(env->regs[3], &sc->regs.r3);
3461 __get_user(env->regs[4], &sc->regs.r4);
3462 __get_user(env->regs[5], &sc->regs.r5);
3463 __get_user(env->regs[6], &sc->regs.r6);
3464 __get_user(env->regs[7], &sc->regs.r7);
3465 __get_user(env->regs[8], &sc->regs.r8);
3466 __get_user(env->regs[9], &sc->regs.r9);
3467 __get_user(env->regs[10], &sc->regs.r10);
3468 __get_user(env->regs[11], &sc->regs.r11);
3469 __get_user(env->regs[12], &sc->regs.r12);
3470 __get_user(env->regs[13], &sc->regs.r13);
3471 __get_user(env->regs[14], &sc->regs.r14);
3472 __get_user(env->regs[15], &sc->regs.r15);
3473 __get_user(env->regs[16], &sc->regs.r16);
3474 __get_user(env->regs[17], &sc->regs.r17);
3475 __get_user(env->regs[18], &sc->regs.r18);
3476 __get_user(env->regs[19], &sc->regs.r19);
3477 __get_user(env->regs[20], &sc->regs.r20);
3478 __get_user(env->regs[21], &sc->regs.r21);
3479 __get_user(env->regs[22], &sc->regs.r22);
3480 __get_user(env->regs[23], &sc->regs.r23);
3481 __get_user(env->regs[24], &sc->regs.r24);
3482 __get_user(env->regs[25], &sc->regs.r25);
3483 __get_user(env->regs[26], &sc->regs.r26);
3484 __get_user(env->regs[27], &sc->regs.r27);
3485 __get_user(env->regs[28], &sc->regs.r28);
3486 __get_user(env->regs[29], &sc->regs.r29);
3487 __get_user(env->regs[30], &sc->regs.r30);
3488 __get_user(env->regs[31], &sc->regs.r31);
3489 __get_user(env->sregs[SR_PC], &sc->regs.pc);
3490}
3491
3492static abi_ulong get_sigframe(struct target_sigaction *ka,
Andreas Färber05390242012-02-25 03:37:53 +01003493 CPUMBState *env, int frame_size)
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003494{
3495 abi_ulong sp = env->regs[1];
3496
Riku Voipiob545f632014-07-15 17:01:55 +03003497 if ((ka->sa_flags & TARGET_SA_ONSTACK) != 0 && !on_sig_stack(sp)) {
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003498 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
Riku Voipiob545f632014-07-15 17:01:55 +03003499 }
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003500
3501 return ((sp - frame_size) & -8UL);
3502}
3503
3504static void setup_frame(int sig, struct target_sigaction *ka,
Andreas Färber05390242012-02-25 03:37:53 +01003505 target_sigset_t *set, CPUMBState *env)
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003506{
3507 struct target_signal_frame *frame;
3508 abi_ulong frame_addr;
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003509 int i;
3510
3511 frame_addr = get_sigframe(ka, env, sizeof *frame);
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01003512 trace_user_setup_frame(env, frame_addr);
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003513 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3514 goto badframe;
3515
3516 /* Save the mask. */
Riku Voipio1d8b5122014-04-23 10:26:05 +03003517 __put_user(set->sig[0], &frame->uc.tuc_mcontext.oldmask);
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003518
3519 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
Riku Voipio0188fad2014-04-23 13:34:15 +03003520 __put_user(set->sig[i], &frame->extramask[i - 1]);
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003521 }
3522
Richard Hendersonf711df62010-11-22 14:57:52 -08003523 setup_sigcontext(&frame->uc.tuc_mcontext, env);
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003524
3525 /* Set up to return from userspace. If provided, use a stub
3526 already in userspace. */
3527 /* minus 8 is offset to cater for "rtsd r15,8" offset */
3528 if (ka->sa_flags & TARGET_SA_RESTORER) {
3529 env->regs[15] = ((unsigned long)ka->sa_restorer)-8;
3530 } else {
3531 uint32_t t;
3532 /* Note, these encodings are _big endian_! */
3533 /* addi r12, r0, __NR_sigreturn */
3534 t = 0x31800000UL | TARGET_NR_sigreturn;
Riku Voipio1d8b5122014-04-23 10:26:05 +03003535 __put_user(t, frame->tramp + 0);
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003536 /* brki r14, 0x8 */
3537 t = 0xb9cc0008UL;
Riku Voipio1d8b5122014-04-23 10:26:05 +03003538 __put_user(t, frame->tramp + 1);
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003539
3540 /* Return from sighandler will jump to the tramp.
3541 Negative 8 offset because return is rtsd r15, 8 */
3542 env->regs[15] = ((unsigned long)frame->tramp) - 8;
3543 }
3544
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003545 /* Set up registers for signal handler */
Edgar E. Iglesiascb9c6262011-08-22 18:44:58 +02003546 env->regs[1] = frame_addr;
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003547 /* Signal handler args: */
3548 env->regs[5] = sig; /* Arg 0: signum */
Edgar E. Iglesias187b4e02010-07-15 15:32:51 +02003549 env->regs[6] = 0;
Edgar E. Iglesiascb9c6262011-08-22 18:44:58 +02003550 /* arg 1: sigcontext */
3551 env->regs[7] = frame_addr += offsetof(typeof(*frame), uc);
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003552
3553 /* Offset of 4 to handle microblaze rtid r14, 0 */
3554 env->sregs[SR_PC] = (unsigned long)ka->_sa_handler;
3555
3556 unlock_user_struct(frame, frame_addr, 1);
3557 return;
3558 badframe:
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003559 force_sig(TARGET_SIGSEGV);
3560}
3561
3562static void setup_rt_frame(int sig, struct target_sigaction *ka,
Anthony Liguoric227f092009-10-01 16:12:16 -05003563 target_siginfo_t *info,
Andreas Färber05390242012-02-25 03:37:53 +01003564 target_sigset_t *set, CPUMBState *env)
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003565{
3566 fprintf(stderr, "Microblaze setup_rt_frame: not implemented\n");
3567}
3568
Andreas Färber05390242012-02-25 03:37:53 +01003569long do_sigreturn(CPUMBState *env)
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003570{
3571 struct target_signal_frame *frame;
3572 abi_ulong frame_addr;
Anthony Liguoric227f092009-10-01 16:12:16 -05003573 target_sigset_t target_set;
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003574 sigset_t set;
3575 int i;
3576
3577 frame_addr = env->regs[R_SP];
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01003578 trace_user_do_sigreturn(env, frame_addr);
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003579 /* Make sure the guest isn't playing games. */
3580 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
3581 goto badframe;
3582
3583 /* Restore blocked signals */
Riku Voipiof5f601a2014-04-23 13:00:17 +03003584 __get_user(target_set.sig[0], &frame->uc.tuc_mcontext.oldmask);
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003585 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
Riku Voipiof5f601a2014-04-23 13:00:17 +03003586 __get_user(target_set.sig[i], &frame->extramask[i - 1]);
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003587 }
3588 target_to_host_sigset_internal(&set, &target_set);
Alex Barcelo1c275922014-03-14 14:36:55 +00003589 do_sigprocmask(SIG_SETMASK, &set, NULL);
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003590
Richard Hendersonf711df62010-11-22 14:57:52 -08003591 restore_sigcontext(&frame->uc.tuc_mcontext, env);
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003592 /* We got here through a sigreturn syscall, our path back is via an
3593 rtb insn so setup r14 for that. */
3594 env->regs[14] = env->sregs[SR_PC];
3595
3596 unlock_user_struct(frame, frame_addr, 0);
3597 return env->regs[10];
3598 badframe:
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003599 force_sig(TARGET_SIGSEGV);
3600}
3601
Andreas Färber05390242012-02-25 03:37:53 +01003602long do_rt_sigreturn(CPUMBState *env)
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003603{
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01003604 trace_user_do_rt_sigreturn(env, 0);
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +02003605 fprintf(stderr, "Microblaze do_rt_sigreturn: not implemented\n");
3606 return -TARGET_ENOSYS;
3607}
3608
edgar_iglb6d3abd2008-02-28 11:29:27 +00003609#elif defined(TARGET_CRIS)
3610
3611struct target_sigcontext {
3612 struct target_pt_regs regs; /* needs to be first */
3613 uint32_t oldmask;
3614 uint32_t usp; /* usp before stacking this gunk on it */
3615};
3616
3617/* Signal frames. */
3618struct target_signal_frame {
3619 struct target_sigcontext sc;
3620 uint32_t extramask[TARGET_NSIG_WORDS - 1];
Stefan Weil8cfc1142014-02-01 09:41:09 +01003621 uint16_t retcode[4]; /* Trampoline code. */
edgar_iglb6d3abd2008-02-28 11:29:27 +00003622};
3623
3624struct rt_signal_frame {
Richard W.M. Jones02d2bd52012-07-05 03:32:44 +00003625 siginfo_t *pinfo;
edgar_iglb6d3abd2008-02-28 11:29:27 +00003626 void *puc;
Richard W.M. Jones02d2bd52012-07-05 03:32:44 +00003627 siginfo_t info;
edgar_iglb6d3abd2008-02-28 11:29:27 +00003628 struct ucontext uc;
Stefan Weil8cfc1142014-02-01 09:41:09 +01003629 uint16_t retcode[4]; /* Trampoline code. */
edgar_iglb6d3abd2008-02-28 11:29:27 +00003630};
3631
Andreas Färber05390242012-02-25 03:37:53 +01003632static void setup_sigcontext(struct target_sigcontext *sc, CPUCRISState *env)
edgar_iglb6d3abd2008-02-28 11:29:27 +00003633{
edgar_igl9664d922008-03-03 22:23:53 +00003634 __put_user(env->regs[0], &sc->regs.r0);
3635 __put_user(env->regs[1], &sc->regs.r1);
3636 __put_user(env->regs[2], &sc->regs.r2);
3637 __put_user(env->regs[3], &sc->regs.r3);
3638 __put_user(env->regs[4], &sc->regs.r4);
3639 __put_user(env->regs[5], &sc->regs.r5);
3640 __put_user(env->regs[6], &sc->regs.r6);
3641 __put_user(env->regs[7], &sc->regs.r7);
3642 __put_user(env->regs[8], &sc->regs.r8);
3643 __put_user(env->regs[9], &sc->regs.r9);
3644 __put_user(env->regs[10], &sc->regs.r10);
3645 __put_user(env->regs[11], &sc->regs.r11);
3646 __put_user(env->regs[12], &sc->regs.r12);
3647 __put_user(env->regs[13], &sc->regs.r13);
3648 __put_user(env->regs[14], &sc->usp);
3649 __put_user(env->regs[15], &sc->regs.acr);
3650 __put_user(env->pregs[PR_MOF], &sc->regs.mof);
3651 __put_user(env->pregs[PR_SRP], &sc->regs.srp);
3652 __put_user(env->pc, &sc->regs.erp);
edgar_iglb6d3abd2008-02-28 11:29:27 +00003653}
edgar_igl9664d922008-03-03 22:23:53 +00003654
Andreas Färber05390242012-02-25 03:37:53 +01003655static void restore_sigcontext(struct target_sigcontext *sc, CPUCRISState *env)
edgar_iglb6d3abd2008-02-28 11:29:27 +00003656{
edgar_igl9664d922008-03-03 22:23:53 +00003657 __get_user(env->regs[0], &sc->regs.r0);
3658 __get_user(env->regs[1], &sc->regs.r1);
3659 __get_user(env->regs[2], &sc->regs.r2);
3660 __get_user(env->regs[3], &sc->regs.r3);
3661 __get_user(env->regs[4], &sc->regs.r4);
3662 __get_user(env->regs[5], &sc->regs.r5);
3663 __get_user(env->regs[6], &sc->regs.r6);
3664 __get_user(env->regs[7], &sc->regs.r7);
3665 __get_user(env->regs[8], &sc->regs.r8);
3666 __get_user(env->regs[9], &sc->regs.r9);
3667 __get_user(env->regs[10], &sc->regs.r10);
3668 __get_user(env->regs[11], &sc->regs.r11);
3669 __get_user(env->regs[12], &sc->regs.r12);
3670 __get_user(env->regs[13], &sc->regs.r13);
3671 __get_user(env->regs[14], &sc->usp);
3672 __get_user(env->regs[15], &sc->regs.acr);
3673 __get_user(env->pregs[PR_MOF], &sc->regs.mof);
3674 __get_user(env->pregs[PR_SRP], &sc->regs.srp);
3675 __get_user(env->pc, &sc->regs.erp);
edgar_iglb6d3abd2008-02-28 11:29:27 +00003676}
3677
Andreas Färber05390242012-02-25 03:37:53 +01003678static abi_ulong get_sigframe(CPUCRISState *env, int framesize)
edgar_iglb6d3abd2008-02-28 11:29:27 +00003679{
edgar_igl9664d922008-03-03 22:23:53 +00003680 abi_ulong sp;
edgar_iglb6d3abd2008-02-28 11:29:27 +00003681 /* Align the stack downwards to 4. */
edgar_igl9664d922008-03-03 22:23:53 +00003682 sp = (env->regs[R_SP] & ~3);
3683 return sp - framesize;
edgar_iglb6d3abd2008-02-28 11:29:27 +00003684}
3685
pbrook624f7972008-05-31 16:11:38 +00003686static void setup_frame(int sig, struct target_sigaction *ka,
Andreas Färber05390242012-02-25 03:37:53 +01003687 target_sigset_t *set, CPUCRISState *env)
edgar_iglb6d3abd2008-02-28 11:29:27 +00003688{
3689 struct target_signal_frame *frame;
edgar_igl9664d922008-03-03 22:23:53 +00003690 abi_ulong frame_addr;
edgar_iglb6d3abd2008-02-28 11:29:27 +00003691 int i;
edgar_iglb6d3abd2008-02-28 11:29:27 +00003692
edgar_igl9664d922008-03-03 22:23:53 +00003693 frame_addr = get_sigframe(env, sizeof *frame);
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01003694 trace_user_setup_frame(env, frame_addr);
edgar_igl9664d922008-03-03 22:23:53 +00003695 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
edgar_iglb6d3abd2008-02-28 11:29:27 +00003696 goto badframe;
3697
3698 /*
3699 * The CRIS signal return trampoline. A real linux/CRIS kernel doesn't
3700 * use this trampoline anymore but it sets it up for GDB.
3701 * In QEMU, using the trampoline simplifies things a bit so we use it.
3702 *
3703 * This is movu.w __NR_sigreturn, r9; break 13;
3704 */
Riku Voipio1d8b5122014-04-23 10:26:05 +03003705 __put_user(0x9c5f, frame->retcode+0);
3706 __put_user(TARGET_NR_sigreturn,
3707 frame->retcode + 1);
3708 __put_user(0xe93d, frame->retcode + 2);
edgar_iglb6d3abd2008-02-28 11:29:27 +00003709
3710 /* Save the mask. */
Riku Voipio1d8b5122014-04-23 10:26:05 +03003711 __put_user(set->sig[0], &frame->sc.oldmask);
edgar_iglb6d3abd2008-02-28 11:29:27 +00003712
Riku Voipio0188fad2014-04-23 13:34:15 +03003713 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3714 __put_user(set->sig[i], &frame->extramask[i - 1]);
3715 }
edgar_iglb6d3abd2008-02-28 11:29:27 +00003716
3717 setup_sigcontext(&frame->sc, env);
3718
3719 /* Move the stack and setup the arguments for the handler. */
Edgar E. Iglesiascb9c6262011-08-22 18:44:58 +02003720 env->regs[R_SP] = frame_addr;
edgar_iglb6d3abd2008-02-28 11:29:27 +00003721 env->regs[10] = sig;
pbrook624f7972008-05-31 16:11:38 +00003722 env->pc = (unsigned long) ka->_sa_handler;
edgar_iglb6d3abd2008-02-28 11:29:27 +00003723 /* Link SRP so the guest returns through the trampoline. */
Edgar E. Iglesiascb9c6262011-08-22 18:44:58 +02003724 env->pregs[PR_SRP] = frame_addr + offsetof(typeof(*frame), retcode);
edgar_iglb6d3abd2008-02-28 11:29:27 +00003725
edgar_igl9664d922008-03-03 22:23:53 +00003726 unlock_user_struct(frame, frame_addr, 1);
edgar_iglb6d3abd2008-02-28 11:29:27 +00003727 return;
3728 badframe:
edgar_iglb6d3abd2008-02-28 11:29:27 +00003729 force_sig(TARGET_SIGSEGV);
3730}
3731
pbrook624f7972008-05-31 16:11:38 +00003732static void setup_rt_frame(int sig, struct target_sigaction *ka,
Anthony Liguoric227f092009-10-01 16:12:16 -05003733 target_siginfo_t *info,
Andreas Färber05390242012-02-25 03:37:53 +01003734 target_sigset_t *set, CPUCRISState *env)
edgar_iglb6d3abd2008-02-28 11:29:27 +00003735{
3736 fprintf(stderr, "CRIS setup_rt_frame: not implemented\n");
3737}
3738
Andreas Färber05390242012-02-25 03:37:53 +01003739long do_sigreturn(CPUCRISState *env)
edgar_iglb6d3abd2008-02-28 11:29:27 +00003740{
3741 struct target_signal_frame *frame;
edgar_igl9664d922008-03-03 22:23:53 +00003742 abi_ulong frame_addr;
Anthony Liguoric227f092009-10-01 16:12:16 -05003743 target_sigset_t target_set;
edgar_iglb6d3abd2008-02-28 11:29:27 +00003744 sigset_t set;
3745 int i;
3746
edgar_igl9664d922008-03-03 22:23:53 +00003747 frame_addr = env->regs[R_SP];
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01003748 trace_user_do_sigreturn(env, frame_addr);
edgar_iglb6d3abd2008-02-28 11:29:27 +00003749 /* Make sure the guest isn't playing games. */
edgar_igl9664d922008-03-03 22:23:53 +00003750 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
edgar_iglb6d3abd2008-02-28 11:29:27 +00003751 goto badframe;
3752
3753 /* Restore blocked signals */
Riku Voipiof5f601a2014-04-23 13:00:17 +03003754 __get_user(target_set.sig[0], &frame->sc.oldmask);
edgar_iglb6d3abd2008-02-28 11:29:27 +00003755 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
Riku Voipiof5f601a2014-04-23 13:00:17 +03003756 __get_user(target_set.sig[i], &frame->extramask[i - 1]);
edgar_iglb6d3abd2008-02-28 11:29:27 +00003757 }
3758 target_to_host_sigset_internal(&set, &target_set);
Alex Barcelo1c275922014-03-14 14:36:55 +00003759 do_sigprocmask(SIG_SETMASK, &set, NULL);
edgar_iglb6d3abd2008-02-28 11:29:27 +00003760
3761 restore_sigcontext(&frame->sc, env);
edgar_igl9664d922008-03-03 22:23:53 +00003762 unlock_user_struct(frame, frame_addr, 0);
edgar_iglb6d3abd2008-02-28 11:29:27 +00003763 return env->regs[10];
3764 badframe:
edgar_iglb6d3abd2008-02-28 11:29:27 +00003765 force_sig(TARGET_SIGSEGV);
3766}
3767
Andreas Färber05390242012-02-25 03:37:53 +01003768long do_rt_sigreturn(CPUCRISState *env)
edgar_iglb6d3abd2008-02-28 11:29:27 +00003769{
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01003770 trace_user_do_rt_sigreturn(env, 0);
edgar_iglb6d3abd2008-02-28 11:29:27 +00003771 fprintf(stderr, "CRIS do_rt_sigreturn: not implemented\n");
3772 return -TARGET_ENOSYS;
3773}
thsc3b5bc82007-12-02 06:31:25 +00003774
Jia Liud9627832012-07-20 15:50:52 +08003775#elif defined(TARGET_OPENRISC)
3776
3777struct target_sigcontext {
3778 struct target_pt_regs regs;
3779 abi_ulong oldmask;
3780 abi_ulong usp;
3781};
3782
3783struct target_ucontext {
3784 abi_ulong tuc_flags;
3785 abi_ulong tuc_link;
3786 target_stack_t tuc_stack;
3787 struct target_sigcontext tuc_mcontext;
3788 target_sigset_t tuc_sigmask; /* mask last for extensibility */
3789};
3790
3791struct target_rt_sigframe {
3792 abi_ulong pinfo;
3793 uint64_t puc;
3794 struct target_siginfo info;
3795 struct target_sigcontext sc;
3796 struct target_ucontext uc;
3797 unsigned char retcode[16]; /* trampoline code */
3798};
3799
3800/* This is the asm-generic/ucontext.h version */
3801#if 0
3802static int restore_sigcontext(CPUOpenRISCState *regs,
3803 struct target_sigcontext *sc)
3804{
3805 unsigned int err = 0;
3806 unsigned long old_usp;
3807
3808 /* Alwys make any pending restarted system call return -EINTR */
3809 current_thread_info()->restart_block.fn = do_no_restart_syscall;
3810
3811 /* restore the regs from &sc->regs (same as sc, since regs is first)
3812 * (sc is already checked for VERIFY_READ since the sigframe was
3813 * checked in sys_sigreturn previously)
3814 */
3815
3816 if (copy_from_user(regs, &sc, sizeof(struct target_pt_regs))) {
3817 goto badframe;
3818 }
3819
3820 /* make sure the U-flag is set so user-mode cannot fool us */
3821
3822 regs->sr &= ~SR_SM;
3823
3824 /* restore the old USP as it was before we stacked the sc etc.
3825 * (we cannot just pop the sigcontext since we aligned the sp and
3826 * stuff after pushing it)
3827 */
3828
Riku Voipio1d8b5122014-04-23 10:26:05 +03003829 __get_user(old_usp, &sc->usp);
Jia Liud9627832012-07-20 15:50:52 +08003830 phx_signal("old_usp 0x%lx", old_usp);
3831
3832 __PHX__ REALLY /* ??? */
3833 wrusp(old_usp);
3834 regs->gpr[1] = old_usp;
3835
3836 /* TODO: the other ports use regs->orig_XX to disable syscall checks
3837 * after this completes, but we don't use that mechanism. maybe we can
3838 * use it now ?
3839 */
3840
3841 return err;
3842
3843badframe:
3844 return 1;
3845}
3846#endif
3847
3848/* Set up a signal frame. */
3849
Riku Voipio41ecc722014-04-23 11:01:00 +03003850static void setup_sigcontext(struct target_sigcontext *sc,
Jia Liud9627832012-07-20 15:50:52 +08003851 CPUOpenRISCState *regs,
3852 unsigned long mask)
3853{
Jia Liud9627832012-07-20 15:50:52 +08003854 unsigned long usp = regs->gpr[1];
3855
3856 /* copy the regs. they are first in sc so we can use sc directly */
3857
Riku Voipio1d8b5122014-04-23 10:26:05 +03003858 /*copy_to_user(&sc, regs, sizeof(struct target_pt_regs));*/
Jia Liud9627832012-07-20 15:50:52 +08003859
3860 /* Set the frametype to CRIS_FRAME_NORMAL for the execution of
3861 the signal handler. The frametype will be restored to its previous
3862 value in restore_sigcontext. */
3863 /*regs->frametype = CRIS_FRAME_NORMAL;*/
3864
3865 /* then some other stuff */
Riku Voipio1d8b5122014-04-23 10:26:05 +03003866 __put_user(mask, &sc->oldmask);
Riku Voipio41ecc722014-04-23 11:01:00 +03003867 __put_user(usp, &sc->usp);
Jia Liud9627832012-07-20 15:50:52 +08003868}
3869
3870static inline unsigned long align_sigframe(unsigned long sp)
3871{
3872 unsigned long i;
3873 i = sp & ~3UL;
3874 return i;
3875}
3876
3877static inline abi_ulong get_sigframe(struct target_sigaction *ka,
3878 CPUOpenRISCState *regs,
3879 size_t frame_size)
3880{
3881 unsigned long sp = regs->gpr[1];
3882 int onsigstack = on_sig_stack(sp);
3883
3884 /* redzone */
3885 /* This is the X/Open sanctioned signal stack switching. */
Riku Voipiob545f632014-07-15 17:01:55 +03003886 if ((ka->sa_flags & TARGET_SA_ONSTACK) != 0 && !onsigstack) {
Jia Liud9627832012-07-20 15:50:52 +08003887 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
3888 }
3889
3890 sp = align_sigframe(sp - frame_size);
3891
3892 /*
3893 * If we are on the alternate signal stack and would overflow it, don't.
3894 * Return an always-bogus address instead so we will die with SIGSEGV.
3895 */
3896
3897 if (onsigstack && !likely(on_sig_stack(sp))) {
3898 return -1L;
3899 }
3900
3901 return sp;
3902}
3903
Jia Liud9627832012-07-20 15:50:52 +08003904static void setup_rt_frame(int sig, struct target_sigaction *ka,
3905 target_siginfo_t *info,
3906 target_sigset_t *set, CPUOpenRISCState *env)
3907{
3908 int err = 0;
3909 abi_ulong frame_addr;
3910 unsigned long return_ip;
3911 struct target_rt_sigframe *frame;
3912 abi_ulong info_addr, uc_addr;
3913
Jia Liud9627832012-07-20 15:50:52 +08003914 frame_addr = get_sigframe(ka, env, sizeof(*frame));
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01003915 trace_user_setup_rt_frame(env, frame_addr);
Jia Liud9627832012-07-20 15:50:52 +08003916 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
3917 goto give_sigsegv;
3918 }
3919
3920 info_addr = frame_addr + offsetof(struct target_rt_sigframe, info);
Riku Voipio1d8b5122014-04-23 10:26:05 +03003921 __put_user(info_addr, &frame->pinfo);
Jia Liud9627832012-07-20 15:50:52 +08003922 uc_addr = frame_addr + offsetof(struct target_rt_sigframe, uc);
Riku Voipio1d8b5122014-04-23 10:26:05 +03003923 __put_user(uc_addr, &frame->puc);
Jia Liud9627832012-07-20 15:50:52 +08003924
3925 if (ka->sa_flags & SA_SIGINFO) {
Peter Maydellf6c7a052015-01-08 12:19:48 +00003926 tswap_siginfo(&frame->info, info);
Jia Liud9627832012-07-20 15:50:52 +08003927 }
3928
3929 /*err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext));*/
Riku Voipio1d8b5122014-04-23 10:26:05 +03003930 __put_user(0, &frame->uc.tuc_flags);
3931 __put_user(0, &frame->uc.tuc_link);
3932 __put_user(target_sigaltstack_used.ss_sp,
3933 &frame->uc.tuc_stack.ss_sp);
3934 __put_user(sas_ss_flags(env->gpr[1]), &frame->uc.tuc_stack.ss_flags);
3935 __put_user(target_sigaltstack_used.ss_size,
3936 &frame->uc.tuc_stack.ss_size);
Riku Voipio41ecc722014-04-23 11:01:00 +03003937 setup_sigcontext(&frame->sc, env, set->sig[0]);
Jia Liud9627832012-07-20 15:50:52 +08003938
3939 /*err |= copy_to_user(frame->uc.tuc_sigmask, set, sizeof(*set));*/
3940
Jia Liud9627832012-07-20 15:50:52 +08003941 /* trampoline - the desired return ip is the retcode itself */
3942 return_ip = (unsigned long)&frame->retcode;
3943 /* This is l.ori r11,r0,__NR_sigreturn, l.sys 1 */
Riku Voipio1d8b5122014-04-23 10:26:05 +03003944 __put_user(0xa960, (short *)(frame->retcode + 0));
3945 __put_user(TARGET_NR_rt_sigreturn, (short *)(frame->retcode + 2));
3946 __put_user(0x20000001, (unsigned long *)(frame->retcode + 4));
3947 __put_user(0x15000000, (unsigned long *)(frame->retcode + 8));
Jia Liud9627832012-07-20 15:50:52 +08003948
3949 if (err) {
3950 goto give_sigsegv;
3951 }
3952
3953 /* TODO what is the current->exec_domain stuff and invmap ? */
3954
3955 /* Set up registers for signal handler */
3956 env->pc = (unsigned long)ka->_sa_handler; /* what we enter NOW */
3957 env->gpr[9] = (unsigned long)return_ip; /* what we enter LATER */
3958 env->gpr[3] = (unsigned long)sig; /* arg 1: signo */
3959 env->gpr[4] = (unsigned long)&frame->info; /* arg 2: (siginfo_t*) */
3960 env->gpr[5] = (unsigned long)&frame->uc; /* arg 3: ucontext */
3961
3962 /* actually move the usp to reflect the stacked frame */
3963 env->gpr[1] = (unsigned long)frame;
3964
3965 return;
3966
3967give_sigsegv:
3968 unlock_user_struct(frame, frame_addr, 1);
3969 if (sig == TARGET_SIGSEGV) {
3970 ka->_sa_handler = TARGET_SIG_DFL;
3971 }
3972 force_sig(TARGET_SIGSEGV);
3973}
3974
3975long do_sigreturn(CPUOpenRISCState *env)
3976{
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01003977 trace_user_do_sigreturn(env, 0);
3978 fprintf(stderr, "do_sigreturn: not implemented\n");
Jia Liud9627832012-07-20 15:50:52 +08003979 return -TARGET_ENOSYS;
3980}
3981
3982long do_rt_sigreturn(CPUOpenRISCState *env)
3983{
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01003984 trace_user_do_rt_sigreturn(env, 0);
3985 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
Jia Liud9627832012-07-20 15:50:52 +08003986 return -TARGET_ENOSYS;
3987}
3988/* TARGET_OPENRISC */
3989
Ulrich Hechta4c075f2009-07-24 16:57:31 +02003990#elif defined(TARGET_S390X)
3991
3992#define __NUM_GPRS 16
3993#define __NUM_FPRS 16
3994#define __NUM_ACRS 16
3995
3996#define S390_SYSCALL_SIZE 2
3997#define __SIGNAL_FRAMESIZE 160 /* FIXME: 31-bit mode -> 96 */
3998
3999#define _SIGCONTEXT_NSIG 64
4000#define _SIGCONTEXT_NSIG_BPW 64 /* FIXME: 31-bit mode -> 32 */
4001#define _SIGCONTEXT_NSIG_WORDS (_SIGCONTEXT_NSIG / _SIGCONTEXT_NSIG_BPW)
4002#define _SIGMASK_COPY_SIZE (sizeof(unsigned long)*_SIGCONTEXT_NSIG_WORDS)
4003#define PSW_ADDR_AMODE 0x0000000000000000UL /* 0x80000000UL for 31-bit */
4004#define S390_SYSCALL_OPCODE ((uint16_t)0x0a00)
4005
4006typedef struct {
4007 target_psw_t psw;
4008 target_ulong gprs[__NUM_GPRS];
4009 unsigned int acrs[__NUM_ACRS];
4010} target_s390_regs_common;
4011
4012typedef struct {
4013 unsigned int fpc;
4014 double fprs[__NUM_FPRS];
4015} target_s390_fp_regs;
4016
4017typedef struct {
4018 target_s390_regs_common regs;
4019 target_s390_fp_regs fpregs;
4020} target_sigregs;
4021
4022struct target_sigcontext {
4023 target_ulong oldmask[_SIGCONTEXT_NSIG_WORDS];
4024 target_sigregs *sregs;
4025};
4026
4027typedef struct {
4028 uint8_t callee_used_stack[__SIGNAL_FRAMESIZE];
4029 struct target_sigcontext sc;
4030 target_sigregs sregs;
4031 int signo;
4032 uint8_t retcode[S390_SYSCALL_SIZE];
4033} sigframe;
4034
4035struct target_ucontext {
Peter Maydell6fea2ea2011-07-12 21:27:15 +01004036 target_ulong tuc_flags;
4037 struct target_ucontext *tuc_link;
4038 target_stack_t tuc_stack;
4039 target_sigregs tuc_mcontext;
4040 target_sigset_t tuc_sigmask; /* mask last for extensibility */
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004041};
4042
4043typedef struct {
4044 uint8_t callee_used_stack[__SIGNAL_FRAMESIZE];
4045 uint8_t retcode[S390_SYSCALL_SIZE];
4046 struct target_siginfo info;
4047 struct target_ucontext uc;
4048} rt_sigframe;
4049
4050static inline abi_ulong
Andreas Färber05390242012-02-25 03:37:53 +01004051get_sigframe(struct target_sigaction *ka, CPUS390XState *env, size_t frame_size)
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004052{
4053 abi_ulong sp;
4054
4055 /* Default to using normal stack */
4056 sp = env->regs[15];
4057
4058 /* This is the X/Open sanctioned signal stack switching. */
4059 if (ka->sa_flags & TARGET_SA_ONSTACK) {
4060 if (!sas_ss_flags(sp)) {
4061 sp = target_sigaltstack_used.ss_sp +
4062 target_sigaltstack_used.ss_size;
4063 }
4064 }
4065
4066 /* This is the legacy signal stack switching. */
4067 else if (/* FIXME !user_mode(regs) */ 0 &&
4068 !(ka->sa_flags & TARGET_SA_RESTORER) &&
4069 ka->sa_restorer) {
4070 sp = (abi_ulong) ka->sa_restorer;
4071 }
4072
4073 return (sp - frame_size) & -8ul;
4074}
4075
Andreas Färber05390242012-02-25 03:37:53 +01004076static void save_sigregs(CPUS390XState *env, target_sigregs *sregs)
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004077{
4078 int i;
4079 //save_access_regs(current->thread.acrs); FIXME
4080
4081 /* Copy a 'clean' PSW mask to the user to avoid leaking
4082 information about whether PER is currently on. */
4083 __put_user(env->psw.mask, &sregs->regs.psw.mask);
4084 __put_user(env->psw.addr, &sregs->regs.psw.addr);
4085 for (i = 0; i < 16; i++) {
4086 __put_user(env->regs[i], &sregs->regs.gprs[i]);
4087 }
4088 for (i = 0; i < 16; i++) {
4089 __put_user(env->aregs[i], &sregs->regs.acrs[i]);
4090 }
4091 /*
4092 * We have to store the fp registers to current->thread.fp_regs
4093 * to merge them with the emulated registers.
4094 */
4095 //save_fp_regs(&current->thread.fp_regs); FIXME
4096 for (i = 0; i < 16; i++) {
Eric Farmanc498d8e2015-05-07 14:35:44 -04004097 __put_user(get_freg(env, i)->ll, &sregs->fpregs.fprs[i]);
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004098 }
4099}
4100
4101static void setup_frame(int sig, struct target_sigaction *ka,
Andreas Färber05390242012-02-25 03:37:53 +01004102 target_sigset_t *set, CPUS390XState *env)
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004103{
4104 sigframe *frame;
4105 abi_ulong frame_addr;
4106
4107 frame_addr = get_sigframe(ka, env, sizeof(*frame));
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01004108 trace_user_setup_frame(env, frame_addr);
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004109 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
4110 goto give_sigsegv;
4111 }
4112
Riku Voipio0188fad2014-04-23 13:34:15 +03004113 __put_user(set->sig[0], &frame->sc.oldmask[0]);
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004114
4115 save_sigregs(env, &frame->sregs);
4116
4117 __put_user((abi_ulong)(unsigned long)&frame->sregs,
4118 (abi_ulong *)&frame->sc.sregs);
4119
4120 /* Set up to return from userspace. If provided, use a stub
4121 already in userspace. */
4122 if (ka->sa_flags & TARGET_SA_RESTORER) {
4123 env->regs[14] = (unsigned long)
4124 ka->sa_restorer | PSW_ADDR_AMODE;
4125 } else {
4126 env->regs[14] = (unsigned long)
4127 frame->retcode | PSW_ADDR_AMODE;
Riku Voipio0188fad2014-04-23 13:34:15 +03004128 __put_user(S390_SYSCALL_OPCODE | TARGET_NR_sigreturn,
4129 (uint16_t *)(frame->retcode));
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004130 }
4131
4132 /* Set up backchain. */
Riku Voipio0188fad2014-04-23 13:34:15 +03004133 __put_user(env->regs[15], (abi_ulong *) frame);
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004134
4135 /* Set up registers for signal handler */
Edgar E. Iglesiascb9c6262011-08-22 18:44:58 +02004136 env->regs[15] = frame_addr;
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004137 env->psw.addr = (target_ulong) ka->_sa_handler | PSW_ADDR_AMODE;
4138
4139 env->regs[2] = sig; //map_signal(sig);
Edgar E. Iglesiascb9c6262011-08-22 18:44:58 +02004140 env->regs[3] = frame_addr += offsetof(typeof(*frame), sc);
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004141
4142 /* We forgot to include these in the sigcontext.
4143 To avoid breaking binary compatibility, they are passed as args. */
4144 env->regs[4] = 0; // FIXME: no clue... current->thread.trap_no;
4145 env->regs[5] = 0; // FIXME: no clue... current->thread.prot_addr;
4146
4147 /* Place signal number on stack to allow backtrace from handler. */
Riku Voipio0188fad2014-04-23 13:34:15 +03004148 __put_user(env->regs[2], (int *) &frame->signo);
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004149 unlock_user_struct(frame, frame_addr, 1);
4150 return;
4151
4152give_sigsegv:
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004153 force_sig(TARGET_SIGSEGV);
4154}
4155
4156static void setup_rt_frame(int sig, struct target_sigaction *ka,
4157 target_siginfo_t *info,
Andreas Färber05390242012-02-25 03:37:53 +01004158 target_sigset_t *set, CPUS390XState *env)
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004159{
4160 int i;
4161 rt_sigframe *frame;
4162 abi_ulong frame_addr;
4163
4164 frame_addr = get_sigframe(ka, env, sizeof *frame);
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01004165 trace_user_setup_rt_frame(env, frame_addr);
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004166 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
4167 goto give_sigsegv;
4168 }
4169
Peter Maydellf6c7a052015-01-08 12:19:48 +00004170 tswap_siginfo(&frame->info, info);
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004171
4172 /* Create the ucontext. */
Peter Maydell6fea2ea2011-07-12 21:27:15 +01004173 __put_user(0, &frame->uc.tuc_flags);
4174 __put_user((abi_ulong)0, (abi_ulong *)&frame->uc.tuc_link);
4175 __put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp);
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004176 __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
Peter Maydell6fea2ea2011-07-12 21:27:15 +01004177 &frame->uc.tuc_stack.ss_flags);
4178 __put_user(target_sigaltstack_used.ss_size, &frame->uc.tuc_stack.ss_size);
4179 save_sigregs(env, &frame->uc.tuc_mcontext);
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004180 for (i = 0; i < TARGET_NSIG_WORDS; i++) {
4181 __put_user((abi_ulong)set->sig[i],
Peter Maydell6fea2ea2011-07-12 21:27:15 +01004182 (abi_ulong *)&frame->uc.tuc_sigmask.sig[i]);
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004183 }
4184
4185 /* Set up to return from userspace. If provided, use a stub
4186 already in userspace. */
4187 if (ka->sa_flags & TARGET_SA_RESTORER) {
4188 env->regs[14] = (unsigned long) ka->sa_restorer | PSW_ADDR_AMODE;
4189 } else {
4190 env->regs[14] = (unsigned long) frame->retcode | PSW_ADDR_AMODE;
Riku Voipio0188fad2014-04-23 13:34:15 +03004191 __put_user(S390_SYSCALL_OPCODE | TARGET_NR_rt_sigreturn,
4192 (uint16_t *)(frame->retcode));
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004193 }
4194
4195 /* Set up backchain. */
Riku Voipio0188fad2014-04-23 13:34:15 +03004196 __put_user(env->regs[15], (abi_ulong *) frame);
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004197
4198 /* Set up registers for signal handler */
Edgar E. Iglesiascb9c6262011-08-22 18:44:58 +02004199 env->regs[15] = frame_addr;
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004200 env->psw.addr = (target_ulong) ka->_sa_handler | PSW_ADDR_AMODE;
4201
4202 env->regs[2] = sig; //map_signal(sig);
Edgar E. Iglesiascb9c6262011-08-22 18:44:58 +02004203 env->regs[3] = frame_addr + offsetof(typeof(*frame), info);
4204 env->regs[4] = frame_addr + offsetof(typeof(*frame), uc);
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004205 return;
4206
4207give_sigsegv:
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004208 force_sig(TARGET_SIGSEGV);
4209}
4210
4211static int
Andreas Färber05390242012-02-25 03:37:53 +01004212restore_sigregs(CPUS390XState *env, target_sigregs *sc)
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004213{
4214 int err = 0;
4215 int i;
4216
4217 for (i = 0; i < 16; i++) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03004218 __get_user(env->regs[i], &sc->regs.gprs[i]);
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004219 }
4220
Riku Voipio1d8b5122014-04-23 10:26:05 +03004221 __get_user(env->psw.mask, &sc->regs.psw.mask);
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01004222 trace_user_s390x_restore_sigregs(env, (unsigned long long)sc->regs.psw.addr,
4223 (unsigned long long)env->psw.addr);
Riku Voipio1d8b5122014-04-23 10:26:05 +03004224 __get_user(env->psw.addr, &sc->regs.psw.addr);
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004225 /* FIXME: 31-bit -> | PSW_ADDR_AMODE */
4226
4227 for (i = 0; i < 16; i++) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03004228 __get_user(env->aregs[i], &sc->regs.acrs[i]);
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004229 }
4230 for (i = 0; i < 16; i++) {
Eric Farmanc498d8e2015-05-07 14:35:44 -04004231 __get_user(get_freg(env, i)->ll, &sc->fpregs.fprs[i]);
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004232 }
4233
4234 return err;
4235}
4236
Andreas Färber05390242012-02-25 03:37:53 +01004237long do_sigreturn(CPUS390XState *env)
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004238{
4239 sigframe *frame;
4240 abi_ulong frame_addr = env->regs[15];
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004241 target_sigset_t target_set;
4242 sigset_t set;
4243
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01004244 trace_user_do_sigreturn(env, frame_addr);
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004245 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
4246 goto badframe;
4247 }
Riku Voipiof5f601a2014-04-23 13:00:17 +03004248 __get_user(target_set.sig[0], &frame->sc.oldmask[0]);
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004249
4250 target_to_host_sigset_internal(&set, &target_set);
Alex Barcelo1c275922014-03-14 14:36:55 +00004251 do_sigprocmask(SIG_SETMASK, &set, NULL); /* ~_BLOCKABLE? */
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004252
4253 if (restore_sigregs(env, &frame->sregs)) {
4254 goto badframe;
4255 }
4256
4257 unlock_user_struct(frame, frame_addr, 0);
4258 return env->regs[2];
4259
4260badframe:
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004261 force_sig(TARGET_SIGSEGV);
4262 return 0;
4263}
4264
Andreas Färber05390242012-02-25 03:37:53 +01004265long do_rt_sigreturn(CPUS390XState *env)
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004266{
4267 rt_sigframe *frame;
4268 abi_ulong frame_addr = env->regs[15];
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004269 sigset_t set;
4270
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01004271 trace_user_do_rt_sigreturn(env, frame_addr);
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004272 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
4273 goto badframe;
4274 }
Peter Maydell6fea2ea2011-07-12 21:27:15 +01004275 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004276
Alex Barcelo1c275922014-03-14 14:36:55 +00004277 do_sigprocmask(SIG_SETMASK, &set, NULL); /* ~_BLOCKABLE? */
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004278
Peter Maydell6fea2ea2011-07-12 21:27:15 +01004279 if (restore_sigregs(env, &frame->uc.tuc_mcontext)) {
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004280 goto badframe;
4281 }
4282
Peter Maydell6fea2ea2011-07-12 21:27:15 +01004283 if (do_sigaltstack(frame_addr + offsetof(rt_sigframe, uc.tuc_stack), 0,
Ulrich Hechta4c075f2009-07-24 16:57:31 +02004284 get_sp_from_cpustate(env)) == -EFAULT) {
4285 goto badframe;
4286 }
4287 unlock_user_struct(frame, frame_addr, 0);
4288 return env->regs[2];
4289
4290badframe:
4291 unlock_user_struct(frame, frame_addr, 0);
4292 force_sig(TARGET_SIGSEGV);
4293 return 0;
4294}
4295
Tom Musta61e75fe2014-06-30 08:13:38 -05004296#elif defined(TARGET_PPC)
Nathan Froydbcd49332009-05-12 19:13:18 -07004297
4298/* Size of dummy stack frame allocated when calling signal handler.
4299 See arch/powerpc/include/asm/ptrace.h. */
4300#if defined(TARGET_PPC64)
4301#define SIGNAL_FRAMESIZE 128
4302#else
4303#define SIGNAL_FRAMESIZE 64
4304#endif
4305
Tom Musta61e75fe2014-06-30 08:13:38 -05004306/* See arch/powerpc/include/asm/ucontext.h. Only used for 32-bit PPC;
4307 on 64-bit PPC, sigcontext and mcontext are one and the same. */
4308struct target_mcontext {
4309 target_ulong mc_gregs[48];
4310 /* Includes fpscr. */
4311 uint64_t mc_fregs[33];
4312 target_ulong mc_pad[2];
4313 /* We need to handle Altivec and SPE at the same time, which no
4314 kernel needs to do. Fortunately, the kernel defines this bit to
4315 be Altivec-register-large all the time, rather than trying to
4316 twiddle it based on the specific platform. */
4317 union {
4318 /* SPE vector registers. One extra for SPEFSCR. */
4319 uint32_t spe[33];
4320 /* Altivec vector registers. The packing of VSCR and VRSAVE
4321 varies depending on whether we're PPC64 or not: PPC64 splits
4322 them apart; PPC32 stuffs them together. */
4323#if defined(TARGET_PPC64)
4324#define QEMU_NVRREG 34
4325#else
4326#define QEMU_NVRREG 33
4327#endif
4328 ppc_avr_t altivec[QEMU_NVRREG];
4329#undef QEMU_NVRREG
4330 } mc_vregs __attribute__((__aligned__(16)));
4331};
4332
Nathan Froydbcd49332009-05-12 19:13:18 -07004333/* See arch/powerpc/include/asm/sigcontext.h. */
4334struct target_sigcontext {
4335 target_ulong _unused[4];
4336 int32_t signal;
4337#if defined(TARGET_PPC64)
4338 int32_t pad0;
4339#endif
4340 target_ulong handler;
4341 target_ulong oldmask;
4342 target_ulong regs; /* struct pt_regs __user * */
Tom Musta61e75fe2014-06-30 08:13:38 -05004343#if defined(TARGET_PPC64)
4344 struct target_mcontext mcontext;
4345#endif
Nathan Froydbcd49332009-05-12 19:13:18 -07004346};
4347
4348/* Indices for target_mcontext.mc_gregs, below.
4349 See arch/powerpc/include/asm/ptrace.h for details. */
4350enum {
4351 TARGET_PT_R0 = 0,
4352 TARGET_PT_R1 = 1,
4353 TARGET_PT_R2 = 2,
4354 TARGET_PT_R3 = 3,
4355 TARGET_PT_R4 = 4,
4356 TARGET_PT_R5 = 5,
4357 TARGET_PT_R6 = 6,
4358 TARGET_PT_R7 = 7,
4359 TARGET_PT_R8 = 8,
4360 TARGET_PT_R9 = 9,
4361 TARGET_PT_R10 = 10,
4362 TARGET_PT_R11 = 11,
4363 TARGET_PT_R12 = 12,
4364 TARGET_PT_R13 = 13,
4365 TARGET_PT_R14 = 14,
4366 TARGET_PT_R15 = 15,
4367 TARGET_PT_R16 = 16,
4368 TARGET_PT_R17 = 17,
4369 TARGET_PT_R18 = 18,
4370 TARGET_PT_R19 = 19,
4371 TARGET_PT_R20 = 20,
4372 TARGET_PT_R21 = 21,
4373 TARGET_PT_R22 = 22,
4374 TARGET_PT_R23 = 23,
4375 TARGET_PT_R24 = 24,
4376 TARGET_PT_R25 = 25,
4377 TARGET_PT_R26 = 26,
4378 TARGET_PT_R27 = 27,
4379 TARGET_PT_R28 = 28,
4380 TARGET_PT_R29 = 29,
4381 TARGET_PT_R30 = 30,
4382 TARGET_PT_R31 = 31,
4383 TARGET_PT_NIP = 32,
4384 TARGET_PT_MSR = 33,
4385 TARGET_PT_ORIG_R3 = 34,
4386 TARGET_PT_CTR = 35,
4387 TARGET_PT_LNK = 36,
4388 TARGET_PT_XER = 37,
4389 TARGET_PT_CCR = 38,
4390 /* Yes, there are two registers with #39. One is 64-bit only. */
4391 TARGET_PT_MQ = 39,
4392 TARGET_PT_SOFTE = 39,
4393 TARGET_PT_TRAP = 40,
4394 TARGET_PT_DAR = 41,
4395 TARGET_PT_DSISR = 42,
4396 TARGET_PT_RESULT = 43,
4397 TARGET_PT_REGS_COUNT = 44
4398};
4399
Nathan Froydbcd49332009-05-12 19:13:18 -07004400
4401struct target_ucontext {
Aurelien Jarno60e99242010-03-29 02:12:51 +02004402 target_ulong tuc_flags;
4403 target_ulong tuc_link; /* struct ucontext __user * */
4404 struct target_sigaltstack tuc_stack;
Nathan Froydbcd49332009-05-12 19:13:18 -07004405#if !defined(TARGET_PPC64)
Aurelien Jarno60e99242010-03-29 02:12:51 +02004406 int32_t tuc_pad[7];
4407 target_ulong tuc_regs; /* struct mcontext __user *
Nathan Froydbcd49332009-05-12 19:13:18 -07004408 points to uc_mcontext field */
4409#endif
Aurelien Jarno60e99242010-03-29 02:12:51 +02004410 target_sigset_t tuc_sigmask;
Nathan Froydbcd49332009-05-12 19:13:18 -07004411#if defined(TARGET_PPC64)
Anthony Liguoric227f092009-10-01 16:12:16 -05004412 target_sigset_t unused[15]; /* Allow for uc_sigmask growth */
Tom Musta61e75fe2014-06-30 08:13:38 -05004413 struct target_sigcontext tuc_sigcontext;
Nathan Froydbcd49332009-05-12 19:13:18 -07004414#else
Aurelien Jarno60e99242010-03-29 02:12:51 +02004415 int32_t tuc_maskext[30];
4416 int32_t tuc_pad2[3];
4417 struct target_mcontext tuc_mcontext;
Nathan Froydbcd49332009-05-12 19:13:18 -07004418#endif
4419};
4420
4421/* See arch/powerpc/kernel/signal_32.c. */
4422struct target_sigframe {
4423 struct target_sigcontext sctx;
4424 struct target_mcontext mctx;
4425 int32_t abigap[56];
4426};
4427
Tom Musta61e75fe2014-06-30 08:13:38 -05004428#if defined(TARGET_PPC64)
4429
4430#define TARGET_TRAMP_SIZE 6
4431
4432struct target_rt_sigframe {
4433 /* sys_rt_sigreturn requires the ucontext be the first field */
4434 struct target_ucontext uc;
4435 target_ulong _unused[2];
4436 uint32_t trampoline[TARGET_TRAMP_SIZE];
4437 target_ulong pinfo; /* struct siginfo __user * */
4438 target_ulong puc; /* void __user * */
4439 struct target_siginfo info;
4440 /* 64 bit ABI allows for 288 bytes below sp before decrementing it. */
4441 char abigap[288];
4442} __attribute__((aligned(16)));
4443
4444#else
4445
Nathan Froydbcd49332009-05-12 19:13:18 -07004446struct target_rt_sigframe {
4447 struct target_siginfo info;
4448 struct target_ucontext uc;
4449 int32_t abigap[56];
4450};
4451
Tom Musta61e75fe2014-06-30 08:13:38 -05004452#endif
4453
Tom Musta8d6ab332014-06-30 08:13:39 -05004454#if defined(TARGET_PPC64)
4455
4456struct target_func_ptr {
4457 target_ulong entry;
4458 target_ulong toc;
4459};
4460
4461#endif
4462
Nathan Froydbcd49332009-05-12 19:13:18 -07004463/* We use the mc_pad field for the signal return trampoline. */
4464#define tramp mc_pad
4465
4466/* See arch/powerpc/kernel/signal.c. */
4467static target_ulong get_sigframe(struct target_sigaction *ka,
Andreas Färber05390242012-02-25 03:37:53 +01004468 CPUPPCState *env,
Nathan Froydbcd49332009-05-12 19:13:18 -07004469 int frame_size)
4470{
4471 target_ulong oldsp, newsp;
4472
4473 oldsp = env->gpr[1];
4474
4475 if ((ka->sa_flags & TARGET_SA_ONSTACK) &&
Alex Barcelo32a20032012-02-09 23:55:46 +00004476 (sas_ss_flags(oldsp) == 0)) {
Nathan Froydbcd49332009-05-12 19:13:18 -07004477 oldsp = (target_sigaltstack_used.ss_sp
4478 + target_sigaltstack_used.ss_size);
4479 }
4480
4481 newsp = (oldsp - frame_size) & ~0xFUL;
4482
4483 return newsp;
4484}
4485
Tom Musta76781082014-06-30 08:13:37 -05004486static void save_user_regs(CPUPPCState *env, struct target_mcontext *frame)
Nathan Froydbcd49332009-05-12 19:13:18 -07004487{
4488 target_ulong msr = env->msr;
4489 int i;
4490 target_ulong ccr = 0;
4491
4492 /* In general, the kernel attempts to be intelligent about what it
4493 needs to save for Altivec/FP/SPE registers. We don't care that
4494 much, so we just go ahead and save everything. */
4495
4496 /* Save general registers. */
4497 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
Riku Voipioc650c002014-04-23 13:53:45 +03004498 __put_user(env->gpr[i], &frame->mc_gregs[i]);
Nathan Froydbcd49332009-05-12 19:13:18 -07004499 }
Riku Voipioc650c002014-04-23 13:53:45 +03004500 __put_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP]);
4501 __put_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR]);
4502 __put_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK]);
4503 __put_user(env->xer, &frame->mc_gregs[TARGET_PT_XER]);
Nathan Froydbcd49332009-05-12 19:13:18 -07004504
4505 for (i = 0; i < ARRAY_SIZE(env->crf); i++) {
4506 ccr |= env->crf[i] << (32 - ((i + 1) * 4));
4507 }
Riku Voipioc650c002014-04-23 13:53:45 +03004508 __put_user(ccr, &frame->mc_gregs[TARGET_PT_CCR]);
Nathan Froydbcd49332009-05-12 19:13:18 -07004509
4510 /* Save Altivec registers if necessary. */
4511 if (env->insns_flags & PPC_ALTIVEC) {
4512 for (i = 0; i < ARRAY_SIZE(env->avr); i++) {
Anthony Liguoric227f092009-10-01 16:12:16 -05004513 ppc_avr_t *avr = &env->avr[i];
4514 ppc_avr_t *vreg = &frame->mc_vregs.altivec[i];
Nathan Froydbcd49332009-05-12 19:13:18 -07004515
Riku Voipioc650c002014-04-23 13:53:45 +03004516 __put_user(avr->u64[0], &vreg->u64[0]);
4517 __put_user(avr->u64[1], &vreg->u64[1]);
Nathan Froydbcd49332009-05-12 19:13:18 -07004518 }
4519 /* Set MSR_VR in the saved MSR value to indicate that
4520 frame->mc_vregs contains valid data. */
4521 msr |= MSR_VR;
Riku Voipioc650c002014-04-23 13:53:45 +03004522 __put_user((uint32_t)env->spr[SPR_VRSAVE],
4523 &frame->mc_vregs.altivec[32].u32[3]);
Nathan Froydbcd49332009-05-12 19:13:18 -07004524 }
4525
4526 /* Save floating point registers. */
4527 if (env->insns_flags & PPC_FLOAT) {
4528 for (i = 0; i < ARRAY_SIZE(env->fpr); i++) {
Riku Voipioc650c002014-04-23 13:53:45 +03004529 __put_user(env->fpr[i], &frame->mc_fregs[i]);
Nathan Froydbcd49332009-05-12 19:13:18 -07004530 }
Riku Voipioc650c002014-04-23 13:53:45 +03004531 __put_user((uint64_t) env->fpscr, &frame->mc_fregs[32]);
Nathan Froydbcd49332009-05-12 19:13:18 -07004532 }
4533
4534 /* Save SPE registers. The kernel only saves the high half. */
4535 if (env->insns_flags & PPC_SPE) {
4536#if defined(TARGET_PPC64)
4537 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
Riku Voipioc650c002014-04-23 13:53:45 +03004538 __put_user(env->gpr[i] >> 32, &frame->mc_vregs.spe[i]);
Nathan Froydbcd49332009-05-12 19:13:18 -07004539 }
4540#else
4541 for (i = 0; i < ARRAY_SIZE(env->gprh); i++) {
Riku Voipioc650c002014-04-23 13:53:45 +03004542 __put_user(env->gprh[i], &frame->mc_vregs.spe[i]);
Nathan Froydbcd49332009-05-12 19:13:18 -07004543 }
4544#endif
4545 /* Set MSR_SPE in the saved MSR value to indicate that
4546 frame->mc_vregs contains valid data. */
4547 msr |= MSR_SPE;
Riku Voipioc650c002014-04-23 13:53:45 +03004548 __put_user(env->spe_fscr, &frame->mc_vregs.spe[32]);
Nathan Froydbcd49332009-05-12 19:13:18 -07004549 }
4550
4551 /* Store MSR. */
Riku Voipioc650c002014-04-23 13:53:45 +03004552 __put_user(msr, &frame->mc_gregs[TARGET_PT_MSR]);
Tom Musta76781082014-06-30 08:13:37 -05004553}
Nathan Froydbcd49332009-05-12 19:13:18 -07004554
Tom Musta76781082014-06-30 08:13:37 -05004555static void encode_trampoline(int sigret, uint32_t *tramp)
4556{
Nathan Froydbcd49332009-05-12 19:13:18 -07004557 /* Set up the sigreturn trampoline: li r0,sigret; sc. */
4558 if (sigret) {
Tom Musta76781082014-06-30 08:13:37 -05004559 __put_user(0x38000000 | sigret, &tramp[0]);
4560 __put_user(0x44000002, &tramp[1]);
Nathan Froydbcd49332009-05-12 19:13:18 -07004561 }
Nathan Froydbcd49332009-05-12 19:13:18 -07004562}
4563
Riku Voipioc650c002014-04-23 13:53:45 +03004564static void restore_user_regs(CPUPPCState *env,
4565 struct target_mcontext *frame, int sig)
Nathan Froydbcd49332009-05-12 19:13:18 -07004566{
4567 target_ulong save_r2 = 0;
4568 target_ulong msr;
4569 target_ulong ccr;
4570
4571 int i;
4572
4573 if (!sig) {
4574 save_r2 = env->gpr[2];
4575 }
4576
4577 /* Restore general registers. */
4578 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
Riku Voipioc650c002014-04-23 13:53:45 +03004579 __get_user(env->gpr[i], &frame->mc_gregs[i]);
Nathan Froydbcd49332009-05-12 19:13:18 -07004580 }
Riku Voipioc650c002014-04-23 13:53:45 +03004581 __get_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP]);
4582 __get_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR]);
4583 __get_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK]);
4584 __get_user(env->xer, &frame->mc_gregs[TARGET_PT_XER]);
4585 __get_user(ccr, &frame->mc_gregs[TARGET_PT_CCR]);
Nathan Froydbcd49332009-05-12 19:13:18 -07004586
4587 for (i = 0; i < ARRAY_SIZE(env->crf); i++) {
4588 env->crf[i] = (ccr >> (32 - ((i + 1) * 4))) & 0xf;
4589 }
4590
4591 if (!sig) {
4592 env->gpr[2] = save_r2;
4593 }
4594 /* Restore MSR. */
Riku Voipioc650c002014-04-23 13:53:45 +03004595 __get_user(msr, &frame->mc_gregs[TARGET_PT_MSR]);
Nathan Froydbcd49332009-05-12 19:13:18 -07004596
4597 /* If doing signal return, restore the previous little-endian mode. */
4598 if (sig)
4599 env->msr = (env->msr & ~MSR_LE) | (msr & MSR_LE);
4600
4601 /* Restore Altivec registers if necessary. */
4602 if (env->insns_flags & PPC_ALTIVEC) {
4603 for (i = 0; i < ARRAY_SIZE(env->avr); i++) {
Anthony Liguoric227f092009-10-01 16:12:16 -05004604 ppc_avr_t *avr = &env->avr[i];
4605 ppc_avr_t *vreg = &frame->mc_vregs.altivec[i];
Nathan Froydbcd49332009-05-12 19:13:18 -07004606
Riku Voipioc650c002014-04-23 13:53:45 +03004607 __get_user(avr->u64[0], &vreg->u64[0]);
4608 __get_user(avr->u64[1], &vreg->u64[1]);
Nathan Froydbcd49332009-05-12 19:13:18 -07004609 }
4610 /* Set MSR_VEC in the saved MSR value to indicate that
4611 frame->mc_vregs contains valid data. */
Riku Voipioc650c002014-04-23 13:53:45 +03004612 __get_user(env->spr[SPR_VRSAVE],
4613 (target_ulong *)(&frame->mc_vregs.altivec[32].u32[3]));
Nathan Froydbcd49332009-05-12 19:13:18 -07004614 }
4615
4616 /* Restore floating point registers. */
4617 if (env->insns_flags & PPC_FLOAT) {
4618 uint64_t fpscr;
4619 for (i = 0; i < ARRAY_SIZE(env->fpr); i++) {
Riku Voipioc650c002014-04-23 13:53:45 +03004620 __get_user(env->fpr[i], &frame->mc_fregs[i]);
Nathan Froydbcd49332009-05-12 19:13:18 -07004621 }
Riku Voipioc650c002014-04-23 13:53:45 +03004622 __get_user(fpscr, &frame->mc_fregs[32]);
Nathan Froydbcd49332009-05-12 19:13:18 -07004623 env->fpscr = (uint32_t) fpscr;
4624 }
4625
4626 /* Save SPE registers. The kernel only saves the high half. */
4627 if (env->insns_flags & PPC_SPE) {
4628#if defined(TARGET_PPC64)
4629 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
4630 uint32_t hi;
4631
Riku Voipioc650c002014-04-23 13:53:45 +03004632 __get_user(hi, &frame->mc_vregs.spe[i]);
Nathan Froydbcd49332009-05-12 19:13:18 -07004633 env->gpr[i] = ((uint64_t)hi << 32) | ((uint32_t) env->gpr[i]);
4634 }
4635#else
4636 for (i = 0; i < ARRAY_SIZE(env->gprh); i++) {
Riku Voipioc650c002014-04-23 13:53:45 +03004637 __get_user(env->gprh[i], &frame->mc_vregs.spe[i]);
Nathan Froydbcd49332009-05-12 19:13:18 -07004638 }
4639#endif
Riku Voipioc650c002014-04-23 13:53:45 +03004640 __get_user(env->spe_fscr, &frame->mc_vregs.spe[32]);
Nathan Froydbcd49332009-05-12 19:13:18 -07004641 }
Nathan Froydbcd49332009-05-12 19:13:18 -07004642}
4643
4644static void setup_frame(int sig, struct target_sigaction *ka,
Andreas Färber05390242012-02-25 03:37:53 +01004645 target_sigset_t *set, CPUPPCState *env)
Nathan Froydbcd49332009-05-12 19:13:18 -07004646{
4647 struct target_sigframe *frame;
4648 struct target_sigcontext *sc;
4649 target_ulong frame_addr, newsp;
4650 int err = 0;
Tom Musta14585582014-06-30 08:13:42 -05004651#if defined(TARGET_PPC64)
4652 struct image_info *image = ((TaskState *)thread_cpu->opaque)->info;
4653#endif
Nathan Froydbcd49332009-05-12 19:13:18 -07004654
4655 frame_addr = get_sigframe(ka, env, sizeof(*frame));
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01004656 trace_user_setup_frame(env, frame_addr);
Nathan Froydbcd49332009-05-12 19:13:18 -07004657 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
4658 goto sigsegv;
4659 sc = &frame->sctx;
4660
Riku Voipio1d8b5122014-04-23 10:26:05 +03004661 __put_user(ka->_sa_handler, &sc->handler);
4662 __put_user(set->sig[0], &sc->oldmask);
Tom Musta61e75fe2014-06-30 08:13:38 -05004663#if TARGET_ABI_BITS == 64
Riku Voipio1d8b5122014-04-23 10:26:05 +03004664 __put_user(set->sig[0] >> 32, &sc->_unused[3]);
Nathan Froydbcd49332009-05-12 19:13:18 -07004665#else
Riku Voipio1d8b5122014-04-23 10:26:05 +03004666 __put_user(set->sig[1], &sc->_unused[3]);
Nathan Froydbcd49332009-05-12 19:13:18 -07004667#endif
Riku Voipio1d8b5122014-04-23 10:26:05 +03004668 __put_user(h2g(&frame->mctx), &sc->regs);
4669 __put_user(sig, &sc->signal);
Nathan Froydbcd49332009-05-12 19:13:18 -07004670
4671 /* Save user regs. */
Tom Musta76781082014-06-30 08:13:37 -05004672 save_user_regs(env, &frame->mctx);
4673
4674 /* Construct the trampoline code on the stack. */
4675 encode_trampoline(TARGET_NR_sigreturn, (uint32_t *)&frame->mctx.tramp);
Nathan Froydbcd49332009-05-12 19:13:18 -07004676
4677 /* The kernel checks for the presence of a VDSO here. We don't
4678 emulate a vdso, so use a sigreturn system call. */
4679 env->lr = (target_ulong) h2g(frame->mctx.tramp);
4680
4681 /* Turn off all fp exceptions. */
4682 env->fpscr = 0;
4683
4684 /* Create a stack frame for the caller of the handler. */
4685 newsp = frame_addr - SIGNAL_FRAMESIZE;
Samuel Seaybeb526b2013-01-02 10:53:46 +00004686 err |= put_user(env->gpr[1], newsp, target_ulong);
Nathan Froydbcd49332009-05-12 19:13:18 -07004687
4688 if (err)
4689 goto sigsegv;
4690
4691 /* Set up registers for signal handler. */
4692 env->gpr[1] = newsp;
Peter Maydellb6e2c932015-01-08 12:19:43 +00004693 env->gpr[3] = sig;
Samuel Seay61993a62013-01-04 14:35:48 +00004694 env->gpr[4] = frame_addr + offsetof(struct target_sigframe, sctx);
Tom Musta8d6ab332014-06-30 08:13:39 -05004695
4696#if defined(TARGET_PPC64)
Tom Musta14585582014-06-30 08:13:42 -05004697 if (get_ppc64_abi(image) < 2) {
4698 /* ELFv1 PPC64 function pointers are pointers to OPD entries. */
4699 struct target_func_ptr *handler =
4700 (struct target_func_ptr *)g2h(ka->_sa_handler);
4701 env->nip = tswapl(handler->entry);
4702 env->gpr[2] = tswapl(handler->toc);
4703 } else {
4704 /* ELFv2 PPC64 function pointers are entry points, but R12
4705 * must also be set */
4706 env->nip = tswapl((target_ulong) ka->_sa_handler);
4707 env->gpr[12] = env->nip;
4708 }
Tom Musta8d6ab332014-06-30 08:13:39 -05004709#else
Nathan Froydbcd49332009-05-12 19:13:18 -07004710 env->nip = (target_ulong) ka->_sa_handler;
Tom Musta8d6ab332014-06-30 08:13:39 -05004711#endif
4712
Nathan Froydbcd49332009-05-12 19:13:18 -07004713 /* Signal handlers are entered in big-endian mode. */
4714 env->msr &= ~MSR_LE;
4715
4716 unlock_user_struct(frame, frame_addr, 1);
4717 return;
4718
4719sigsegv:
4720 unlock_user_struct(frame, frame_addr, 1);
Riku Voipio66393fb2009-12-04 15:16:32 +02004721 force_sig(TARGET_SIGSEGV);
Nathan Froydbcd49332009-05-12 19:13:18 -07004722}
4723
4724static void setup_rt_frame(int sig, struct target_sigaction *ka,
Anthony Liguoric227f092009-10-01 16:12:16 -05004725 target_siginfo_t *info,
Andreas Färber05390242012-02-25 03:37:53 +01004726 target_sigset_t *set, CPUPPCState *env)
Nathan Froydbcd49332009-05-12 19:13:18 -07004727{
4728 struct target_rt_sigframe *rt_sf;
Tom Musta61e75fe2014-06-30 08:13:38 -05004729 uint32_t *trampptr = 0;
4730 struct target_mcontext *mctx = 0;
Nathan Froydbcd49332009-05-12 19:13:18 -07004731 target_ulong rt_sf_addr, newsp = 0;
4732 int i, err = 0;
Tom Musta14585582014-06-30 08:13:42 -05004733#if defined(TARGET_PPC64)
4734 struct image_info *image = ((TaskState *)thread_cpu->opaque)->info;
4735#endif
Nathan Froydbcd49332009-05-12 19:13:18 -07004736
4737 rt_sf_addr = get_sigframe(ka, env, sizeof(*rt_sf));
4738 if (!lock_user_struct(VERIFY_WRITE, rt_sf, rt_sf_addr, 1))
4739 goto sigsegv;
4740
Peter Maydellf6c7a052015-01-08 12:19:48 +00004741 tswap_siginfo(&rt_sf->info, info);
Nathan Froydbcd49332009-05-12 19:13:18 -07004742
Riku Voipio1d8b5122014-04-23 10:26:05 +03004743 __put_user(0, &rt_sf->uc.tuc_flags);
4744 __put_user(0, &rt_sf->uc.tuc_link);
4745 __put_user((target_ulong)target_sigaltstack_used.ss_sp,
4746 &rt_sf->uc.tuc_stack.ss_sp);
4747 __put_user(sas_ss_flags(env->gpr[1]),
4748 &rt_sf->uc.tuc_stack.ss_flags);
4749 __put_user(target_sigaltstack_used.ss_size,
4750 &rt_sf->uc.tuc_stack.ss_size);
Tom Musta61e75fe2014-06-30 08:13:38 -05004751#if !defined(TARGET_PPC64)
Riku Voipio1d8b5122014-04-23 10:26:05 +03004752 __put_user(h2g (&rt_sf->uc.tuc_mcontext),
4753 &rt_sf->uc.tuc_regs);
Tom Musta61e75fe2014-06-30 08:13:38 -05004754#endif
Nathan Froydbcd49332009-05-12 19:13:18 -07004755 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03004756 __put_user(set->sig[i], &rt_sf->uc.tuc_sigmask.sig[i]);
Nathan Froydbcd49332009-05-12 19:13:18 -07004757 }
4758
Tom Musta61e75fe2014-06-30 08:13:38 -05004759#if defined(TARGET_PPC64)
4760 mctx = &rt_sf->uc.tuc_sigcontext.mcontext;
4761 trampptr = &rt_sf->trampoline[0];
4762#else
4763 mctx = &rt_sf->uc.tuc_mcontext;
4764 trampptr = (uint32_t *)&rt_sf->uc.tuc_mcontext.tramp;
4765#endif
4766
4767 save_user_regs(env, mctx);
4768 encode_trampoline(TARGET_NR_rt_sigreturn, trampptr);
Nathan Froydbcd49332009-05-12 19:13:18 -07004769
4770 /* The kernel checks for the presence of a VDSO here. We don't
4771 emulate a vdso, so use a sigreturn system call. */
Tom Musta61e75fe2014-06-30 08:13:38 -05004772 env->lr = (target_ulong) h2g(trampptr);
Nathan Froydbcd49332009-05-12 19:13:18 -07004773
4774 /* Turn off all fp exceptions. */
4775 env->fpscr = 0;
4776
4777 /* Create a stack frame for the caller of the handler. */
4778 newsp = rt_sf_addr - (SIGNAL_FRAMESIZE + 16);
Tom Mustafbdc2002014-06-30 08:13:36 -05004779 err |= put_user(env->gpr[1], newsp, target_ulong);
Nathan Froydbcd49332009-05-12 19:13:18 -07004780
4781 if (err)
4782 goto sigsegv;
4783
4784 /* Set up registers for signal handler. */
4785 env->gpr[1] = newsp;
Peter Maydellb6e2c932015-01-08 12:19:43 +00004786 env->gpr[3] = (target_ulong) sig;
Nathan Froydbcd49332009-05-12 19:13:18 -07004787 env->gpr[4] = (target_ulong) h2g(&rt_sf->info);
4788 env->gpr[5] = (target_ulong) h2g(&rt_sf->uc);
4789 env->gpr[6] = (target_ulong) h2g(rt_sf);
Tom Musta8d6ab332014-06-30 08:13:39 -05004790
4791#if defined(TARGET_PPC64)
Tom Musta14585582014-06-30 08:13:42 -05004792 if (get_ppc64_abi(image) < 2) {
4793 /* ELFv1 PPC64 function pointers are pointers to OPD entries. */
4794 struct target_func_ptr *handler =
4795 (struct target_func_ptr *)g2h(ka->_sa_handler);
4796 env->nip = tswapl(handler->entry);
4797 env->gpr[2] = tswapl(handler->toc);
4798 } else {
4799 /* ELFv2 PPC64 function pointers are entry points, but R12
4800 * must also be set */
4801 env->nip = tswapl((target_ulong) ka->_sa_handler);
4802 env->gpr[12] = env->nip;
4803 }
Tom Musta8d6ab332014-06-30 08:13:39 -05004804#else
Nathan Froydbcd49332009-05-12 19:13:18 -07004805 env->nip = (target_ulong) ka->_sa_handler;
Tom Musta8d6ab332014-06-30 08:13:39 -05004806#endif
4807
Nathan Froydbcd49332009-05-12 19:13:18 -07004808 /* Signal handlers are entered in big-endian mode. */
4809 env->msr &= ~MSR_LE;
4810
4811 unlock_user_struct(rt_sf, rt_sf_addr, 1);
4812 return;
4813
4814sigsegv:
4815 unlock_user_struct(rt_sf, rt_sf_addr, 1);
Riku Voipio66393fb2009-12-04 15:16:32 +02004816 force_sig(TARGET_SIGSEGV);
Nathan Froydbcd49332009-05-12 19:13:18 -07004817
4818}
4819
Andreas Färber05390242012-02-25 03:37:53 +01004820long do_sigreturn(CPUPPCState *env)
Nathan Froydbcd49332009-05-12 19:13:18 -07004821{
4822 struct target_sigcontext *sc = NULL;
4823 struct target_mcontext *sr = NULL;
Peter Maydellb04636f2013-07-29 12:00:31 +01004824 target_ulong sr_addr = 0, sc_addr;
Nathan Froydbcd49332009-05-12 19:13:18 -07004825 sigset_t blocked;
Anthony Liguoric227f092009-10-01 16:12:16 -05004826 target_sigset_t set;
Nathan Froydbcd49332009-05-12 19:13:18 -07004827
4828 sc_addr = env->gpr[1] + SIGNAL_FRAMESIZE;
4829 if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1))
4830 goto sigsegv;
4831
4832#if defined(TARGET_PPC64)
Tom Musta61e75fe2014-06-30 08:13:38 -05004833 set.sig[0] = sc->oldmask + ((uint64_t)(sc->_unused[3]) << 32);
Nathan Froydbcd49332009-05-12 19:13:18 -07004834#else
Riku Voipiof5f601a2014-04-23 13:00:17 +03004835 __get_user(set.sig[0], &sc->oldmask);
4836 __get_user(set.sig[1], &sc->_unused[3]);
Nathan Froydbcd49332009-05-12 19:13:18 -07004837#endif
4838 target_to_host_sigset_internal(&blocked, &set);
Alex Barcelo1c275922014-03-14 14:36:55 +00004839 do_sigprocmask(SIG_SETMASK, &blocked, NULL);
Nathan Froydbcd49332009-05-12 19:13:18 -07004840
Riku Voipiof5f601a2014-04-23 13:00:17 +03004841 __get_user(sr_addr, &sc->regs);
Nathan Froydbcd49332009-05-12 19:13:18 -07004842 if (!lock_user_struct(VERIFY_READ, sr, sr_addr, 1))
4843 goto sigsegv;
Riku Voipioc650c002014-04-23 13:53:45 +03004844 restore_user_regs(env, sr, 1);
Nathan Froydbcd49332009-05-12 19:13:18 -07004845
4846 unlock_user_struct(sr, sr_addr, 1);
4847 unlock_user_struct(sc, sc_addr, 1);
4848 return -TARGET_QEMU_ESIGRETURN;
4849
4850sigsegv:
4851 unlock_user_struct(sr, sr_addr, 1);
4852 unlock_user_struct(sc, sc_addr, 1);
Riku Voipio66393fb2009-12-04 15:16:32 +02004853 force_sig(TARGET_SIGSEGV);
Nathan Froydbcd49332009-05-12 19:13:18 -07004854 return 0;
4855}
4856
4857/* See arch/powerpc/kernel/signal_32.c. */
Andreas Färber05390242012-02-25 03:37:53 +01004858static int do_setcontext(struct target_ucontext *ucp, CPUPPCState *env, int sig)
Nathan Froydbcd49332009-05-12 19:13:18 -07004859{
4860 struct target_mcontext *mcp;
4861 target_ulong mcp_addr;
4862 sigset_t blocked;
Anthony Liguoric227f092009-10-01 16:12:16 -05004863 target_sigset_t set;
Nathan Froydbcd49332009-05-12 19:13:18 -07004864
Aurelien Jarno60e99242010-03-29 02:12:51 +02004865 if (copy_from_user(&set, h2g(ucp) + offsetof(struct target_ucontext, tuc_sigmask),
Nathan Froydbcd49332009-05-12 19:13:18 -07004866 sizeof (set)))
4867 return 1;
4868
Tom Musta19774ec2014-06-30 08:13:40 -05004869#if defined(TARGET_PPC64)
4870 mcp_addr = h2g(ucp) +
4871 offsetof(struct target_ucontext, tuc_sigcontext.mcontext);
4872#else
Riku Voipio9e918dc2014-04-23 14:05:09 +03004873 __get_user(mcp_addr, &ucp->tuc_regs);
Tom Musta19774ec2014-06-30 08:13:40 -05004874#endif
Nathan Froydbcd49332009-05-12 19:13:18 -07004875
4876 if (!lock_user_struct(VERIFY_READ, mcp, mcp_addr, 1))
4877 return 1;
4878
4879 target_to_host_sigset_internal(&blocked, &set);
Alex Barcelo1c275922014-03-14 14:36:55 +00004880 do_sigprocmask(SIG_SETMASK, &blocked, NULL);
Riku Voipioc650c002014-04-23 13:53:45 +03004881 restore_user_regs(env, mcp, sig);
Nathan Froydbcd49332009-05-12 19:13:18 -07004882
4883 unlock_user_struct(mcp, mcp_addr, 1);
4884 return 0;
Nathan Froydbcd49332009-05-12 19:13:18 -07004885}
4886
Andreas Färber05390242012-02-25 03:37:53 +01004887long do_rt_sigreturn(CPUPPCState *env)
Nathan Froydbcd49332009-05-12 19:13:18 -07004888{
4889 struct target_rt_sigframe *rt_sf = NULL;
4890 target_ulong rt_sf_addr;
4891
4892 rt_sf_addr = env->gpr[1] + SIGNAL_FRAMESIZE + 16;
4893 if (!lock_user_struct(VERIFY_READ, rt_sf, rt_sf_addr, 1))
4894 goto sigsegv;
4895
4896 if (do_setcontext(&rt_sf->uc, env, 1))
4897 goto sigsegv;
4898
4899 do_sigaltstack(rt_sf_addr
Aurelien Jarno60e99242010-03-29 02:12:51 +02004900 + offsetof(struct target_rt_sigframe, uc.tuc_stack),
Nathan Froydbcd49332009-05-12 19:13:18 -07004901 0, env->gpr[1]);
4902
4903 unlock_user_struct(rt_sf, rt_sf_addr, 1);
4904 return -TARGET_QEMU_ESIGRETURN;
4905
4906sigsegv:
4907 unlock_user_struct(rt_sf, rt_sf_addr, 1);
Riku Voipio66393fb2009-12-04 15:16:32 +02004908 force_sig(TARGET_SIGSEGV);
Nathan Froydbcd49332009-05-12 19:13:18 -07004909 return 0;
4910}
4911
Laurent Vivier492a8742009-08-03 16:12:17 +02004912#elif defined(TARGET_M68K)
4913
4914struct target_sigcontext {
4915 abi_ulong sc_mask;
4916 abi_ulong sc_usp;
4917 abi_ulong sc_d0;
4918 abi_ulong sc_d1;
4919 abi_ulong sc_a0;
4920 abi_ulong sc_a1;
4921 unsigned short sc_sr;
4922 abi_ulong sc_pc;
4923};
4924
4925struct target_sigframe
4926{
4927 abi_ulong pretcode;
4928 int sig;
4929 int code;
4930 abi_ulong psc;
4931 char retcode[8];
4932 abi_ulong extramask[TARGET_NSIG_WORDS-1];
4933 struct target_sigcontext sc;
4934};
Laurent Vivier71811552009-08-03 16:12:18 +02004935
Anthony Liguoric227f092009-10-01 16:12:16 -05004936typedef int target_greg_t;
Laurent Vivier71811552009-08-03 16:12:18 +02004937#define TARGET_NGREG 18
Anthony Liguoric227f092009-10-01 16:12:16 -05004938typedef target_greg_t target_gregset_t[TARGET_NGREG];
Laurent Vivier71811552009-08-03 16:12:18 +02004939
4940typedef struct target_fpregset {
4941 int f_fpcntl[3];
4942 int f_fpregs[8*3];
Anthony Liguoric227f092009-10-01 16:12:16 -05004943} target_fpregset_t;
Laurent Vivier71811552009-08-03 16:12:18 +02004944
4945struct target_mcontext {
4946 int version;
Anthony Liguoric227f092009-10-01 16:12:16 -05004947 target_gregset_t gregs;
4948 target_fpregset_t fpregs;
Laurent Vivier71811552009-08-03 16:12:18 +02004949};
4950
4951#define TARGET_MCONTEXT_VERSION 2
4952
4953struct target_ucontext {
Aurelien Jarno60e99242010-03-29 02:12:51 +02004954 abi_ulong tuc_flags;
4955 abi_ulong tuc_link;
4956 target_stack_t tuc_stack;
4957 struct target_mcontext tuc_mcontext;
4958 abi_long tuc_filler[80];
4959 target_sigset_t tuc_sigmask;
Laurent Vivier71811552009-08-03 16:12:18 +02004960};
4961
4962struct target_rt_sigframe
4963{
4964 abi_ulong pretcode;
4965 int sig;
4966 abi_ulong pinfo;
4967 abi_ulong puc;
4968 char retcode[8];
4969 struct target_siginfo info;
4970 struct target_ucontext uc;
4971};
Laurent Vivier492a8742009-08-03 16:12:17 +02004972
Riku Voipio41ecc722014-04-23 11:01:00 +03004973static void setup_sigcontext(struct target_sigcontext *sc, CPUM68KState *env,
4974 abi_ulong mask)
Laurent Vivier492a8742009-08-03 16:12:17 +02004975{
Riku Voipio1d8b5122014-04-23 10:26:05 +03004976 __put_user(mask, &sc->sc_mask);
4977 __put_user(env->aregs[7], &sc->sc_usp);
4978 __put_user(env->dregs[0], &sc->sc_d0);
4979 __put_user(env->dregs[1], &sc->sc_d1);
4980 __put_user(env->aregs[0], &sc->sc_a0);
4981 __put_user(env->aregs[1], &sc->sc_a1);
4982 __put_user(env->sr, &sc->sc_sr);
4983 __put_user(env->pc, &sc->sc_pc);
Laurent Vivier492a8742009-08-03 16:12:17 +02004984}
4985
Riku Voipio016d2e12014-04-23 11:19:48 +03004986static void
Andreas Färber05390242012-02-25 03:37:53 +01004987restore_sigcontext(CPUM68KState *env, struct target_sigcontext *sc, int *pd0)
Laurent Vivier492a8742009-08-03 16:12:17 +02004988{
Laurent Vivier492a8742009-08-03 16:12:17 +02004989 int temp;
4990
Riku Voipio1d8b5122014-04-23 10:26:05 +03004991 __get_user(env->aregs[7], &sc->sc_usp);
4992 __get_user(env->dregs[1], &sc->sc_d1);
4993 __get_user(env->aregs[0], &sc->sc_a0);
4994 __get_user(env->aregs[1], &sc->sc_a1);
4995 __get_user(env->pc, &sc->sc_pc);
4996 __get_user(temp, &sc->sc_sr);
Laurent Vivier492a8742009-08-03 16:12:17 +02004997 env->sr = (env->sr & 0xff00) | (temp & 0xff);
4998
4999 *pd0 = tswapl(sc->sc_d0);
Laurent Vivier492a8742009-08-03 16:12:17 +02005000}
5001
5002/*
5003 * Determine which stack to use..
5004 */
5005static inline abi_ulong
Andreas Färber05390242012-02-25 03:37:53 +01005006get_sigframe(struct target_sigaction *ka, CPUM68KState *regs,
5007 size_t frame_size)
Laurent Vivier492a8742009-08-03 16:12:17 +02005008{
5009 unsigned long sp;
5010
5011 sp = regs->aregs[7];
5012
5013 /* This is the X/Open sanctioned signal stack switching. */
5014 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) {
5015 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
5016 }
5017
5018 return ((sp - frame_size) & -8UL);
5019}
5020
5021static void setup_frame(int sig, struct target_sigaction *ka,
Andreas Färber05390242012-02-25 03:37:53 +01005022 target_sigset_t *set, CPUM68KState *env)
Laurent Vivier492a8742009-08-03 16:12:17 +02005023{
5024 struct target_sigframe *frame;
5025 abi_ulong frame_addr;
5026 abi_ulong retcode_addr;
5027 abi_ulong sc_addr;
Laurent Vivier492a8742009-08-03 16:12:17 +02005028 int i;
5029
5030 frame_addr = get_sigframe(ka, env, sizeof *frame);
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01005031 trace_user_setup_frame(env, frame_addr);
Laurent Vivier492a8742009-08-03 16:12:17 +02005032 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
5033 goto give_sigsegv;
5034
Riku Voipio1d8b5122014-04-23 10:26:05 +03005035 __put_user(sig, &frame->sig);
Laurent Vivier492a8742009-08-03 16:12:17 +02005036
5037 sc_addr = frame_addr + offsetof(struct target_sigframe, sc);
Riku Voipio1d8b5122014-04-23 10:26:05 +03005038 __put_user(sc_addr, &frame->psc);
Laurent Vivier492a8742009-08-03 16:12:17 +02005039
Riku Voipio41ecc722014-04-23 11:01:00 +03005040 setup_sigcontext(&frame->sc, env, set->sig[0]);
Laurent Vivier492a8742009-08-03 16:12:17 +02005041
5042 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
Riku Voipio0188fad2014-04-23 13:34:15 +03005043 __put_user(set->sig[i], &frame->extramask[i - 1]);
Laurent Vivier492a8742009-08-03 16:12:17 +02005044 }
5045
5046 /* Set up to return from userspace. */
5047
5048 retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode);
Riku Voipio1d8b5122014-04-23 10:26:05 +03005049 __put_user(retcode_addr, &frame->pretcode);
Laurent Vivier492a8742009-08-03 16:12:17 +02005050
5051 /* moveq #,d0; trap #0 */
5052
Riku Voipio1d8b5122014-04-23 10:26:05 +03005053 __put_user(0x70004e40 + (TARGET_NR_sigreturn << 16),
Peter Maydell1669add2014-12-22 17:47:00 +00005054 (uint32_t *)(frame->retcode));
Laurent Vivier492a8742009-08-03 16:12:17 +02005055
Laurent Vivier492a8742009-08-03 16:12:17 +02005056 /* Set up to return from userspace */
5057
5058 env->aregs[7] = frame_addr;
5059 env->pc = ka->_sa_handler;
5060
5061 unlock_user_struct(frame, frame_addr, 1);
5062 return;
5063
5064give_sigsegv:
Riku Voipio66393fb2009-12-04 15:16:32 +02005065 force_sig(TARGET_SIGSEGV);
Laurent Vivier492a8742009-08-03 16:12:17 +02005066}
5067
Laurent Vivier71811552009-08-03 16:12:18 +02005068static inline int target_rt_setup_ucontext(struct target_ucontext *uc,
Andreas Färber05390242012-02-25 03:37:53 +01005069 CPUM68KState *env)
Laurent Vivier71811552009-08-03 16:12:18 +02005070{
Aurelien Jarno60e99242010-03-29 02:12:51 +02005071 target_greg_t *gregs = uc->tuc_mcontext.gregs;
Laurent Vivier71811552009-08-03 16:12:18 +02005072
Riku Voipio1d8b5122014-04-23 10:26:05 +03005073 __put_user(TARGET_MCONTEXT_VERSION, &uc->tuc_mcontext.version);
5074 __put_user(env->dregs[0], &gregs[0]);
5075 __put_user(env->dregs[1], &gregs[1]);
5076 __put_user(env->dregs[2], &gregs[2]);
5077 __put_user(env->dregs[3], &gregs[3]);
5078 __put_user(env->dregs[4], &gregs[4]);
5079 __put_user(env->dregs[5], &gregs[5]);
5080 __put_user(env->dregs[6], &gregs[6]);
5081 __put_user(env->dregs[7], &gregs[7]);
5082 __put_user(env->aregs[0], &gregs[8]);
5083 __put_user(env->aregs[1], &gregs[9]);
5084 __put_user(env->aregs[2], &gregs[10]);
5085 __put_user(env->aregs[3], &gregs[11]);
5086 __put_user(env->aregs[4], &gregs[12]);
5087 __put_user(env->aregs[5], &gregs[13]);
5088 __put_user(env->aregs[6], &gregs[14]);
5089 __put_user(env->aregs[7], &gregs[15]);
5090 __put_user(env->pc, &gregs[16]);
5091 __put_user(env->sr, &gregs[17]);
Laurent Vivier71811552009-08-03 16:12:18 +02005092
Riku Voipio1d8b5122014-04-23 10:26:05 +03005093 return 0;
Laurent Vivier71811552009-08-03 16:12:18 +02005094}
5095
Andreas Färber05390242012-02-25 03:37:53 +01005096static inline int target_rt_restore_ucontext(CPUM68KState *env,
Laurent Vivier71811552009-08-03 16:12:18 +02005097 struct target_ucontext *uc,
5098 int *pd0)
5099{
5100 int temp;
Aurelien Jarno60e99242010-03-29 02:12:51 +02005101 target_greg_t *gregs = uc->tuc_mcontext.gregs;
Laurent Vivier71811552009-08-03 16:12:18 +02005102
Riku Voipio1d8b5122014-04-23 10:26:05 +03005103 __get_user(temp, &uc->tuc_mcontext.version);
Laurent Vivier71811552009-08-03 16:12:18 +02005104 if (temp != TARGET_MCONTEXT_VERSION)
5105 goto badframe;
5106
5107 /* restore passed registers */
Riku Voipio1d8b5122014-04-23 10:26:05 +03005108 __get_user(env->dregs[0], &gregs[0]);
5109 __get_user(env->dregs[1], &gregs[1]);
5110 __get_user(env->dregs[2], &gregs[2]);
5111 __get_user(env->dregs[3], &gregs[3]);
5112 __get_user(env->dregs[4], &gregs[4]);
5113 __get_user(env->dregs[5], &gregs[5]);
5114 __get_user(env->dregs[6], &gregs[6]);
5115 __get_user(env->dregs[7], &gregs[7]);
5116 __get_user(env->aregs[0], &gregs[8]);
5117 __get_user(env->aregs[1], &gregs[9]);
5118 __get_user(env->aregs[2], &gregs[10]);
5119 __get_user(env->aregs[3], &gregs[11]);
5120 __get_user(env->aregs[4], &gregs[12]);
5121 __get_user(env->aregs[5], &gregs[13]);
5122 __get_user(env->aregs[6], &gregs[14]);
5123 __get_user(env->aregs[7], &gregs[15]);
5124 __get_user(env->pc, &gregs[16]);
5125 __get_user(temp, &gregs[17]);
Laurent Vivier71811552009-08-03 16:12:18 +02005126 env->sr = (env->sr & 0xff00) | (temp & 0xff);
5127
5128 *pd0 = env->dregs[0];
Riku Voipio1d8b5122014-04-23 10:26:05 +03005129 return 0;
Laurent Vivier71811552009-08-03 16:12:18 +02005130
5131badframe:
5132 return 1;
5133}
5134
Laurent Vivier492a8742009-08-03 16:12:17 +02005135static void setup_rt_frame(int sig, struct target_sigaction *ka,
Anthony Liguoric227f092009-10-01 16:12:16 -05005136 target_siginfo_t *info,
Andreas Färber05390242012-02-25 03:37:53 +01005137 target_sigset_t *set, CPUM68KState *env)
Laurent Vivier492a8742009-08-03 16:12:17 +02005138{
Laurent Vivier71811552009-08-03 16:12:18 +02005139 struct target_rt_sigframe *frame;
5140 abi_ulong frame_addr;
5141 abi_ulong retcode_addr;
5142 abi_ulong info_addr;
5143 abi_ulong uc_addr;
5144 int err = 0;
5145 int i;
5146
5147 frame_addr = get_sigframe(ka, env, sizeof *frame);
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01005148 trace_user_setup_rt_frame(env, frame_addr);
Laurent Vivier71811552009-08-03 16:12:18 +02005149 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
5150 goto give_sigsegv;
5151
Riku Voipio1d8b5122014-04-23 10:26:05 +03005152 __put_user(sig, &frame->sig);
Laurent Vivier71811552009-08-03 16:12:18 +02005153
5154 info_addr = frame_addr + offsetof(struct target_rt_sigframe, info);
Riku Voipio1d8b5122014-04-23 10:26:05 +03005155 __put_user(info_addr, &frame->pinfo);
Laurent Vivier71811552009-08-03 16:12:18 +02005156
5157 uc_addr = frame_addr + offsetof(struct target_rt_sigframe, uc);
Riku Voipio1d8b5122014-04-23 10:26:05 +03005158 __put_user(uc_addr, &frame->puc);
Laurent Vivier71811552009-08-03 16:12:18 +02005159
Peter Maydellf6c7a052015-01-08 12:19:48 +00005160 tswap_siginfo(&frame->info, info);
Laurent Vivier71811552009-08-03 16:12:18 +02005161
5162 /* Create the ucontext */
5163
Riku Voipio1d8b5122014-04-23 10:26:05 +03005164 __put_user(0, &frame->uc.tuc_flags);
5165 __put_user(0, &frame->uc.tuc_link);
5166 __put_user(target_sigaltstack_used.ss_sp,
5167 &frame->uc.tuc_stack.ss_sp);
5168 __put_user(sas_ss_flags(env->aregs[7]),
5169 &frame->uc.tuc_stack.ss_flags);
5170 __put_user(target_sigaltstack_used.ss_size,
5171 &frame->uc.tuc_stack.ss_size);
Laurent Vivier71811552009-08-03 16:12:18 +02005172 err |= target_rt_setup_ucontext(&frame->uc, env);
5173
5174 if (err)
5175 goto give_sigsegv;
5176
5177 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
Riku Voipio0188fad2014-04-23 13:34:15 +03005178 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
Laurent Vivier71811552009-08-03 16:12:18 +02005179 }
5180
5181 /* Set up to return from userspace. */
5182
5183 retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode);
Riku Voipio1d8b5122014-04-23 10:26:05 +03005184 __put_user(retcode_addr, &frame->pretcode);
Laurent Vivier71811552009-08-03 16:12:18 +02005185
5186 /* moveq #,d0; notb d0; trap #0 */
5187
Riku Voipio1d8b5122014-04-23 10:26:05 +03005188 __put_user(0x70004600 + ((TARGET_NR_rt_sigreturn ^ 0xff) << 16),
Peter Maydell1669add2014-12-22 17:47:00 +00005189 (uint32_t *)(frame->retcode + 0));
5190 __put_user(0x4e40, (uint16_t *)(frame->retcode + 4));
Laurent Vivier71811552009-08-03 16:12:18 +02005191
5192 if (err)
5193 goto give_sigsegv;
5194
5195 /* Set up to return from userspace */
5196
5197 env->aregs[7] = frame_addr;
5198 env->pc = ka->_sa_handler;
5199
5200 unlock_user_struct(frame, frame_addr, 1);
5201 return;
5202
5203give_sigsegv:
5204 unlock_user_struct(frame, frame_addr, 1);
Riku Voipio66393fb2009-12-04 15:16:32 +02005205 force_sig(TARGET_SIGSEGV);
Laurent Vivier492a8742009-08-03 16:12:17 +02005206}
5207
Andreas Färber05390242012-02-25 03:37:53 +01005208long do_sigreturn(CPUM68KState *env)
Laurent Vivier492a8742009-08-03 16:12:17 +02005209{
5210 struct target_sigframe *frame;
5211 abi_ulong frame_addr = env->aregs[7] - 4;
Anthony Liguoric227f092009-10-01 16:12:16 -05005212 target_sigset_t target_set;
Laurent Vivier492a8742009-08-03 16:12:17 +02005213 sigset_t set;
5214 int d0, i;
5215
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01005216 trace_user_do_sigreturn(env, frame_addr);
Laurent Vivier492a8742009-08-03 16:12:17 +02005217 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
5218 goto badframe;
5219
5220 /* set blocked signals */
5221
Riku Voipiof5f601a2014-04-23 13:00:17 +03005222 __get_user(target_set.sig[0], &frame->sc.sc_mask);
Laurent Vivier492a8742009-08-03 16:12:17 +02005223
5224 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
Riku Voipiof5f601a2014-04-23 13:00:17 +03005225 __get_user(target_set.sig[i], &frame->extramask[i - 1]);
Laurent Vivier492a8742009-08-03 16:12:17 +02005226 }
5227
5228 target_to_host_sigset_internal(&set, &target_set);
Alex Barcelo1c275922014-03-14 14:36:55 +00005229 do_sigprocmask(SIG_SETMASK, &set, NULL);
Laurent Vivier492a8742009-08-03 16:12:17 +02005230
5231 /* restore registers */
5232
Riku Voipio016d2e12014-04-23 11:19:48 +03005233 restore_sigcontext(env, &frame->sc, &d0);
Laurent Vivier492a8742009-08-03 16:12:17 +02005234
5235 unlock_user_struct(frame, frame_addr, 0);
5236 return d0;
5237
5238badframe:
Laurent Vivier492a8742009-08-03 16:12:17 +02005239 force_sig(TARGET_SIGSEGV);
5240 return 0;
5241}
5242
Andreas Färber05390242012-02-25 03:37:53 +01005243long do_rt_sigreturn(CPUM68KState *env)
Laurent Vivier492a8742009-08-03 16:12:17 +02005244{
Laurent Vivier71811552009-08-03 16:12:18 +02005245 struct target_rt_sigframe *frame;
5246 abi_ulong frame_addr = env->aregs[7] - 4;
Anthony Liguoric227f092009-10-01 16:12:16 -05005247 target_sigset_t target_set;
Laurent Vivier71811552009-08-03 16:12:18 +02005248 sigset_t set;
5249 int d0;
5250
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01005251 trace_user_do_rt_sigreturn(env, frame_addr);
Laurent Vivier71811552009-08-03 16:12:18 +02005252 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
5253 goto badframe;
5254
5255 target_to_host_sigset_internal(&set, &target_set);
Alex Barcelo1c275922014-03-14 14:36:55 +00005256 do_sigprocmask(SIG_SETMASK, &set, NULL);
Laurent Vivier71811552009-08-03 16:12:18 +02005257
5258 /* restore registers */
5259
5260 if (target_rt_restore_ucontext(env, &frame->uc, &d0))
5261 goto badframe;
5262
5263 if (do_sigaltstack(frame_addr +
Aurelien Jarno60e99242010-03-29 02:12:51 +02005264 offsetof(struct target_rt_sigframe, uc.tuc_stack),
Laurent Vivier71811552009-08-03 16:12:18 +02005265 0, get_sp_from_cpustate(env)) == -EFAULT)
5266 goto badframe;
5267
5268 unlock_user_struct(frame, frame_addr, 0);
5269 return d0;
5270
5271badframe:
5272 unlock_user_struct(frame, frame_addr, 0);
5273 force_sig(TARGET_SIGSEGV);
5274 return 0;
Laurent Vivier492a8742009-08-03 16:12:17 +02005275}
5276
Richard Henderson6049f4f2009-12-27 18:30:03 -08005277#elif defined(TARGET_ALPHA)
5278
5279struct target_sigcontext {
5280 abi_long sc_onstack;
5281 abi_long sc_mask;
5282 abi_long sc_pc;
5283 abi_long sc_ps;
5284 abi_long sc_regs[32];
5285 abi_long sc_ownedfp;
5286 abi_long sc_fpregs[32];
5287 abi_ulong sc_fpcr;
5288 abi_ulong sc_fp_control;
5289 abi_ulong sc_reserved1;
5290 abi_ulong sc_reserved2;
5291 abi_ulong sc_ssize;
5292 abi_ulong sc_sbase;
5293 abi_ulong sc_traparg_a0;
5294 abi_ulong sc_traparg_a1;
5295 abi_ulong sc_traparg_a2;
5296 abi_ulong sc_fp_trap_pc;
5297 abi_ulong sc_fp_trigger_sum;
5298 abi_ulong sc_fp_trigger_inst;
5299};
5300
5301struct target_ucontext {
Aurelien Jarno60e99242010-03-29 02:12:51 +02005302 abi_ulong tuc_flags;
5303 abi_ulong tuc_link;
5304 abi_ulong tuc_osf_sigmask;
5305 target_stack_t tuc_stack;
5306 struct target_sigcontext tuc_mcontext;
5307 target_sigset_t tuc_sigmask;
Richard Henderson6049f4f2009-12-27 18:30:03 -08005308};
5309
5310struct target_sigframe {
5311 struct target_sigcontext sc;
5312 unsigned int retcode[3];
5313};
5314
5315struct target_rt_sigframe {
5316 target_siginfo_t info;
5317 struct target_ucontext uc;
5318 unsigned int retcode[3];
5319};
5320
5321#define INSN_MOV_R30_R16 0x47fe0410
5322#define INSN_LDI_R0 0x201f0000
5323#define INSN_CALLSYS 0x00000083
5324
Riku Voipio41ecc722014-04-23 11:01:00 +03005325static void setup_sigcontext(struct target_sigcontext *sc, CPUAlphaState *env,
Richard Henderson6049f4f2009-12-27 18:30:03 -08005326 abi_ulong frame_addr, target_sigset_t *set)
5327{
Riku Voipio41ecc722014-04-23 11:01:00 +03005328 int i;
Richard Henderson6049f4f2009-12-27 18:30:03 -08005329
Riku Voipio1d8b5122014-04-23 10:26:05 +03005330 __put_user(on_sig_stack(frame_addr), &sc->sc_onstack);
5331 __put_user(set->sig[0], &sc->sc_mask);
5332 __put_user(env->pc, &sc->sc_pc);
5333 __put_user(8, &sc->sc_ps);
Richard Henderson6049f4f2009-12-27 18:30:03 -08005334
5335 for (i = 0; i < 31; ++i) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03005336 __put_user(env->ir[i], &sc->sc_regs[i]);
Richard Henderson6049f4f2009-12-27 18:30:03 -08005337 }
Riku Voipio1d8b5122014-04-23 10:26:05 +03005338 __put_user(0, &sc->sc_regs[31]);
Richard Henderson6049f4f2009-12-27 18:30:03 -08005339
5340 for (i = 0; i < 31; ++i) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03005341 __put_user(env->fir[i], &sc->sc_fpregs[i]);
Richard Henderson6049f4f2009-12-27 18:30:03 -08005342 }
Riku Voipio1d8b5122014-04-23 10:26:05 +03005343 __put_user(0, &sc->sc_fpregs[31]);
5344 __put_user(cpu_alpha_load_fpcr(env), &sc->sc_fpcr);
Richard Henderson6049f4f2009-12-27 18:30:03 -08005345
Riku Voipio1d8b5122014-04-23 10:26:05 +03005346 __put_user(0, &sc->sc_traparg_a0); /* FIXME */
5347 __put_user(0, &sc->sc_traparg_a1); /* FIXME */
5348 __put_user(0, &sc->sc_traparg_a2); /* FIXME */
Richard Henderson6049f4f2009-12-27 18:30:03 -08005349}
5350
Riku Voipio016d2e12014-04-23 11:19:48 +03005351static void restore_sigcontext(CPUAlphaState *env,
Andreas Färber05390242012-02-25 03:37:53 +01005352 struct target_sigcontext *sc)
Richard Henderson6049f4f2009-12-27 18:30:03 -08005353{
5354 uint64_t fpcr;
Riku Voipio016d2e12014-04-23 11:19:48 +03005355 int i;
Richard Henderson6049f4f2009-12-27 18:30:03 -08005356
Riku Voipio1d8b5122014-04-23 10:26:05 +03005357 __get_user(env->pc, &sc->sc_pc);
Richard Henderson6049f4f2009-12-27 18:30:03 -08005358
5359 for (i = 0; i < 31; ++i) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03005360 __get_user(env->ir[i], &sc->sc_regs[i]);
Richard Henderson6049f4f2009-12-27 18:30:03 -08005361 }
5362 for (i = 0; i < 31; ++i) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03005363 __get_user(env->fir[i], &sc->sc_fpregs[i]);
Richard Henderson6049f4f2009-12-27 18:30:03 -08005364 }
5365
Riku Voipio1d8b5122014-04-23 10:26:05 +03005366 __get_user(fpcr, &sc->sc_fpcr);
Richard Henderson6049f4f2009-12-27 18:30:03 -08005367 cpu_alpha_store_fpcr(env, fpcr);
Richard Henderson6049f4f2009-12-27 18:30:03 -08005368}
5369
5370static inline abi_ulong get_sigframe(struct target_sigaction *sa,
Andreas Färber05390242012-02-25 03:37:53 +01005371 CPUAlphaState *env,
5372 unsigned long framesize)
Richard Henderson6049f4f2009-12-27 18:30:03 -08005373{
5374 abi_ulong sp = env->ir[IR_SP];
5375
5376 /* This is the X/Open sanctioned signal stack switching. */
5377 if ((sa->sa_flags & TARGET_SA_ONSTACK) != 0 && !sas_ss_flags(sp)) {
5378 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
5379 }
5380 return (sp - framesize) & -32;
5381}
5382
5383static void setup_frame(int sig, struct target_sigaction *ka,
Andreas Färber05390242012-02-25 03:37:53 +01005384 target_sigset_t *set, CPUAlphaState *env)
Richard Henderson6049f4f2009-12-27 18:30:03 -08005385{
5386 abi_ulong frame_addr, r26;
5387 struct target_sigframe *frame;
5388 int err = 0;
5389
5390 frame_addr = get_sigframe(ka, env, sizeof(*frame));
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01005391 trace_user_setup_frame(env, frame_addr);
Richard Henderson6049f4f2009-12-27 18:30:03 -08005392 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
5393 goto give_sigsegv;
5394 }
5395
Riku Voipio41ecc722014-04-23 11:01:00 +03005396 setup_sigcontext(&frame->sc, env, frame_addr, set);
Richard Henderson6049f4f2009-12-27 18:30:03 -08005397
5398 if (ka->sa_restorer) {
5399 r26 = ka->sa_restorer;
5400 } else {
Riku Voipio1d8b5122014-04-23 10:26:05 +03005401 __put_user(INSN_MOV_R30_R16, &frame->retcode[0]);
5402 __put_user(INSN_LDI_R0 + TARGET_NR_sigreturn,
5403 &frame->retcode[1]);
5404 __put_user(INSN_CALLSYS, &frame->retcode[2]);
Richard Henderson6049f4f2009-12-27 18:30:03 -08005405 /* imb() */
5406 r26 = frame_addr;
5407 }
5408
5409 unlock_user_struct(frame, frame_addr, 1);
5410
5411 if (err) {
5412 give_sigsegv:
5413 if (sig == TARGET_SIGSEGV) {
5414 ka->_sa_handler = TARGET_SIG_DFL;
5415 }
5416 force_sig(TARGET_SIGSEGV);
5417 }
5418
5419 env->ir[IR_RA] = r26;
5420 env->ir[IR_PV] = env->pc = ka->_sa_handler;
5421 env->ir[IR_A0] = sig;
5422 env->ir[IR_A1] = 0;
5423 env->ir[IR_A2] = frame_addr + offsetof(struct target_sigframe, sc);
5424 env->ir[IR_SP] = frame_addr;
5425}
5426
5427static void setup_rt_frame(int sig, struct target_sigaction *ka,
5428 target_siginfo_t *info,
Andreas Färber05390242012-02-25 03:37:53 +01005429 target_sigset_t *set, CPUAlphaState *env)
Richard Henderson6049f4f2009-12-27 18:30:03 -08005430{
5431 abi_ulong frame_addr, r26;
5432 struct target_rt_sigframe *frame;
5433 int i, err = 0;
5434
5435 frame_addr = get_sigframe(ka, env, sizeof(*frame));
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01005436 trace_user_setup_rt_frame(env, frame_addr);
Richard Henderson6049f4f2009-12-27 18:30:03 -08005437 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
5438 goto give_sigsegv;
5439 }
5440
Peter Maydellf6c7a052015-01-08 12:19:48 +00005441 tswap_siginfo(&frame->info, info);
Richard Henderson6049f4f2009-12-27 18:30:03 -08005442
Riku Voipio1d8b5122014-04-23 10:26:05 +03005443 __put_user(0, &frame->uc.tuc_flags);
5444 __put_user(0, &frame->uc.tuc_link);
5445 __put_user(set->sig[0], &frame->uc.tuc_osf_sigmask);
5446 __put_user(target_sigaltstack_used.ss_sp,
5447 &frame->uc.tuc_stack.ss_sp);
5448 __put_user(sas_ss_flags(env->ir[IR_SP]),
5449 &frame->uc.tuc_stack.ss_flags);
5450 __put_user(target_sigaltstack_used.ss_size,
5451 &frame->uc.tuc_stack.ss_size);
Riku Voipio41ecc722014-04-23 11:01:00 +03005452 setup_sigcontext(&frame->uc.tuc_mcontext, env, frame_addr, set);
Richard Henderson6049f4f2009-12-27 18:30:03 -08005453 for (i = 0; i < TARGET_NSIG_WORDS; ++i) {
Riku Voipio1d8b5122014-04-23 10:26:05 +03005454 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
Richard Henderson6049f4f2009-12-27 18:30:03 -08005455 }
5456
5457 if (ka->sa_restorer) {
5458 r26 = ka->sa_restorer;
5459 } else {
Riku Voipio1d8b5122014-04-23 10:26:05 +03005460 __put_user(INSN_MOV_R30_R16, &frame->retcode[0]);
5461 __put_user(INSN_LDI_R0 + TARGET_NR_rt_sigreturn,
5462 &frame->retcode[1]);
5463 __put_user(INSN_CALLSYS, &frame->retcode[2]);
Richard Henderson6049f4f2009-12-27 18:30:03 -08005464 /* imb(); */
5465 r26 = frame_addr;
5466 }
5467
5468 if (err) {
5469 give_sigsegv:
5470 if (sig == TARGET_SIGSEGV) {
5471 ka->_sa_handler = TARGET_SIG_DFL;
5472 }
5473 force_sig(TARGET_SIGSEGV);
5474 }
5475
5476 env->ir[IR_RA] = r26;
5477 env->ir[IR_PV] = env->pc = ka->_sa_handler;
5478 env->ir[IR_A0] = sig;
5479 env->ir[IR_A1] = frame_addr + offsetof(struct target_rt_sigframe, info);
5480 env->ir[IR_A2] = frame_addr + offsetof(struct target_rt_sigframe, uc);
5481 env->ir[IR_SP] = frame_addr;
5482}
5483
Andreas Färber05390242012-02-25 03:37:53 +01005484long do_sigreturn(CPUAlphaState *env)
Richard Henderson6049f4f2009-12-27 18:30:03 -08005485{
5486 struct target_sigcontext *sc;
5487 abi_ulong sc_addr = env->ir[IR_A0];
5488 target_sigset_t target_set;
5489 sigset_t set;
5490
5491 if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1)) {
5492 goto badframe;
5493 }
5494
5495 target_sigemptyset(&target_set);
Riku Voipiof5f601a2014-04-23 13:00:17 +03005496 __get_user(target_set.sig[0], &sc->sc_mask);
Richard Henderson6049f4f2009-12-27 18:30:03 -08005497
5498 target_to_host_sigset_internal(&set, &target_set);
Alex Barcelo1c275922014-03-14 14:36:55 +00005499 do_sigprocmask(SIG_SETMASK, &set, NULL);
Richard Henderson6049f4f2009-12-27 18:30:03 -08005500
Riku Voipio016d2e12014-04-23 11:19:48 +03005501 restore_sigcontext(env, sc);
Richard Henderson6049f4f2009-12-27 18:30:03 -08005502 unlock_user_struct(sc, sc_addr, 0);
5503 return env->ir[IR_V0];
5504
5505 badframe:
Richard Henderson6049f4f2009-12-27 18:30:03 -08005506 force_sig(TARGET_SIGSEGV);
5507}
5508
Andreas Färber05390242012-02-25 03:37:53 +01005509long do_rt_sigreturn(CPUAlphaState *env)
Richard Henderson6049f4f2009-12-27 18:30:03 -08005510{
5511 abi_ulong frame_addr = env->ir[IR_A0];
5512 struct target_rt_sigframe *frame;
5513 sigset_t set;
5514
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01005515 trace_user_do_rt_sigreturn(env, frame_addr);
Richard Henderson6049f4f2009-12-27 18:30:03 -08005516 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
5517 goto badframe;
5518 }
Aurelien Jarno60e99242010-03-29 02:12:51 +02005519 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
Alex Barcelo1c275922014-03-14 14:36:55 +00005520 do_sigprocmask(SIG_SETMASK, &set, NULL);
Richard Henderson6049f4f2009-12-27 18:30:03 -08005521
Riku Voipio016d2e12014-04-23 11:19:48 +03005522 restore_sigcontext(env, &frame->uc.tuc_mcontext);
Richard Henderson6049f4f2009-12-27 18:30:03 -08005523 if (do_sigaltstack(frame_addr + offsetof(struct target_rt_sigframe,
Aurelien Jarno60e99242010-03-29 02:12:51 +02005524 uc.tuc_stack),
Richard Henderson6049f4f2009-12-27 18:30:03 -08005525 0, env->ir[IR_SP]) == -EFAULT) {
5526 goto badframe;
5527 }
5528
5529 unlock_user_struct(frame, frame_addr, 0);
5530 return env->ir[IR_V0];
5531
5532
5533 badframe:
5534 unlock_user_struct(frame, frame_addr, 0);
5535 force_sig(TARGET_SIGSEGV);
5536}
5537
Chen Gangbf0f60a2015-09-27 08:10:18 +08005538#elif defined(TARGET_TILEGX)
5539
5540struct target_sigcontext {
5541 union {
5542 /* General-purpose registers. */
5543 abi_ulong gregs[56];
5544 struct {
5545 abi_ulong __gregs[53];
5546 abi_ulong tp; /* Aliases gregs[TREG_TP]. */
5547 abi_ulong sp; /* Aliases gregs[TREG_SP]. */
5548 abi_ulong lr; /* Aliases gregs[TREG_LR]. */
5549 };
5550 };
5551 abi_ulong pc; /* Program counter. */
5552 abi_ulong ics; /* In Interrupt Critical Section? */
5553 abi_ulong faultnum; /* Fault number. */
5554 abi_ulong pad[5];
5555};
5556
5557struct target_ucontext {
5558 abi_ulong tuc_flags;
5559 abi_ulong tuc_link;
5560 target_stack_t tuc_stack;
5561 struct target_sigcontext tuc_mcontext;
5562 target_sigset_t tuc_sigmask; /* mask last for extensibility */
5563};
5564
5565struct target_rt_sigframe {
5566 unsigned char save_area[16]; /* caller save area */
5567 struct target_siginfo info;
5568 struct target_ucontext uc;
5569};
5570
5571static void setup_sigcontext(struct target_sigcontext *sc,
5572 CPUArchState *env, int signo)
5573{
5574 int i;
5575
5576 for (i = 0; i < TILEGX_R_COUNT; ++i) {
5577 __put_user(env->regs[i], &sc->gregs[i]);
5578 }
5579
5580 __put_user(env->pc, &sc->pc);
5581 __put_user(0, &sc->ics);
5582 __put_user(signo, &sc->faultnum);
5583}
5584
5585static void restore_sigcontext(CPUTLGState *env, struct target_sigcontext *sc)
5586{
5587 int i;
5588
5589 for (i = 0; i < TILEGX_R_COUNT; ++i) {
5590 __get_user(env->regs[i], &sc->gregs[i]);
5591 }
5592
5593 __get_user(env->pc, &sc->pc);
5594}
5595
5596static abi_ulong get_sigframe(struct target_sigaction *ka, CPUArchState *env,
5597 size_t frame_size)
5598{
5599 unsigned long sp = env->regs[TILEGX_R_SP];
5600
5601 if (on_sig_stack(sp) && !likely(on_sig_stack(sp - frame_size))) {
5602 return -1UL;
5603 }
5604
5605 if ((ka->sa_flags & SA_ONSTACK) && !sas_ss_flags(sp)) {
5606 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
5607 }
5608
5609 sp -= frame_size;
5610 sp &= -16UL;
5611 return sp;
5612}
5613
5614static void setup_rt_frame(int sig, struct target_sigaction *ka,
5615 target_siginfo_t *info,
5616 target_sigset_t *set, CPUArchState *env)
5617{
5618 abi_ulong frame_addr;
5619 struct target_rt_sigframe *frame;
5620 unsigned long restorer;
5621
5622 frame_addr = get_sigframe(ka, env, sizeof(*frame));
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01005623 trace_user_setup_rt_frame(env, frame_addr);
Chen Gangbf0f60a2015-09-27 08:10:18 +08005624 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
5625 goto give_sigsegv;
5626 }
5627
5628 /* Always write at least the signal number for the stack backtracer. */
5629 if (ka->sa_flags & TARGET_SA_SIGINFO) {
5630 /* At sigreturn time, restore the callee-save registers too. */
5631 tswap_siginfo(&frame->info, info);
5632 /* regs->flags |= PT_FLAGS_RESTORE_REGS; FIXME: we can skip it? */
5633 } else {
5634 __put_user(info->si_signo, &frame->info.si_signo);
5635 }
5636
5637 /* Create the ucontext. */
5638 __put_user(0, &frame->uc.tuc_flags);
5639 __put_user(0, &frame->uc.tuc_link);
5640 __put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp);
5641 __put_user(sas_ss_flags(env->regs[TILEGX_R_SP]),
5642 &frame->uc.tuc_stack.ss_flags);
5643 __put_user(target_sigaltstack_used.ss_size, &frame->uc.tuc_stack.ss_size);
5644 setup_sigcontext(&frame->uc.tuc_mcontext, env, info->si_signo);
5645
5646 restorer = (unsigned long) do_rt_sigreturn;
5647 if (ka->sa_flags & TARGET_SA_RESTORER) {
5648 restorer = (unsigned long) ka->sa_restorer;
5649 }
5650 env->pc = (unsigned long) ka->_sa_handler;
5651 env->regs[TILEGX_R_SP] = (unsigned long) frame;
5652 env->regs[TILEGX_R_LR] = restorer;
5653 env->regs[0] = (unsigned long) sig;
5654 env->regs[1] = (unsigned long) &frame->info;
5655 env->regs[2] = (unsigned long) &frame->uc;
5656 /* regs->flags |= PT_FLAGS_CALLER_SAVES; FIXME: we can skip it? */
5657
5658 unlock_user_struct(frame, frame_addr, 1);
5659 return;
5660
5661give_sigsegv:
5662 if (sig == TARGET_SIGSEGV) {
5663 ka->_sa_handler = TARGET_SIG_DFL;
5664 }
5665 force_sig(TARGET_SIGSEGV /* , current */);
5666}
5667
5668long do_rt_sigreturn(CPUTLGState *env)
5669{
5670 abi_ulong frame_addr = env->regs[TILEGX_R_SP];
5671 struct target_rt_sigframe *frame;
5672 sigset_t set;
5673
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01005674 trace_user_do_rt_sigreturn(env, frame_addr);
Chen Gangbf0f60a2015-09-27 08:10:18 +08005675 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
5676 goto badframe;
5677 }
5678 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
5679 do_sigprocmask(SIG_SETMASK, &set, NULL);
5680
5681 restore_sigcontext(env, &frame->uc.tuc_mcontext);
5682 if (do_sigaltstack(frame_addr + offsetof(struct target_rt_sigframe,
5683 uc.tuc_stack),
5684 0, env->regs[TILEGX_R_SP]) == -EFAULT) {
5685 goto badframe;
5686 }
5687
5688 unlock_user_struct(frame, frame_addr, 0);
5689 return env->regs[TILEGX_R_RE];
5690
5691
5692 badframe:
5693 unlock_user_struct(frame, frame_addr, 0);
5694 force_sig(TARGET_SIGSEGV);
5695}
5696
bellardb346ff42003-06-15 20:05:50 +00005697#else
5698
pbrook624f7972008-05-31 16:11:38 +00005699static void setup_frame(int sig, struct target_sigaction *ka,
Andreas Färber9349b4f2012-03-14 01:38:32 +01005700 target_sigset_t *set, CPUArchState *env)
bellardb346ff42003-06-15 20:05:50 +00005701{
5702 fprintf(stderr, "setup_frame: not implemented\n");
5703}
5704
pbrook624f7972008-05-31 16:11:38 +00005705static void setup_rt_frame(int sig, struct target_sigaction *ka,
Anthony Liguoric227f092009-10-01 16:12:16 -05005706 target_siginfo_t *info,
Andreas Färber9349b4f2012-03-14 01:38:32 +01005707 target_sigset_t *set, CPUArchState *env)
bellardb346ff42003-06-15 20:05:50 +00005708{
5709 fprintf(stderr, "setup_rt_frame: not implemented\n");
5710}
5711
Andreas Färber9349b4f2012-03-14 01:38:32 +01005712long do_sigreturn(CPUArchState *env)
bellardb346ff42003-06-15 20:05:50 +00005713{
5714 fprintf(stderr, "do_sigreturn: not implemented\n");
bellardf8b0aa22007-11-11 23:03:42 +00005715 return -TARGET_ENOSYS;
bellardb346ff42003-06-15 20:05:50 +00005716}
5717
Andreas Färber9349b4f2012-03-14 01:38:32 +01005718long do_rt_sigreturn(CPUArchState *env)
bellardb346ff42003-06-15 20:05:50 +00005719{
5720 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
bellardf8b0aa22007-11-11 23:03:42 +00005721 return -TARGET_ENOSYS;
bellardb346ff42003-06-15 20:05:50 +00005722}
5723
bellard66fb9762003-03-23 01:06:05 +00005724#endif
5725
Andreas Färber9349b4f2012-03-14 01:38:32 +01005726void process_pending_signals(CPUArchState *cpu_env)
bellard66fb9762003-03-23 01:06:05 +00005727{
Andreas Färberdb6b81d2013-06-27 19:49:31 +02005728 CPUState *cpu = ENV_GET_CPU(cpu_env);
bellard66fb9762003-03-23 01:06:05 +00005729 int sig;
blueswir1992f48a2007-10-14 16:27:31 +00005730 abi_ulong handler;
bellard9de5e442003-03-23 16:49:39 +00005731 sigset_t set, old_set;
Anthony Liguoric227f092009-10-01 16:12:16 -05005732 target_sigset_t target_old_set;
pbrook624f7972008-05-31 16:11:38 +00005733 struct emulated_sigtable *k;
5734 struct target_sigaction *sa;
bellard66fb9762003-03-23 01:06:05 +00005735 struct sigqueue *q;
Andreas Färber0429a972013-08-26 18:14:44 +02005736 TaskState *ts = cpu->opaque;
ths3b46e622007-09-17 08:09:54 +00005737
pbrook624f7972008-05-31 16:11:38 +00005738 if (!ts->signal_pending)
bellard31e31b82003-02-18 22:55:36 +00005739 return;
5740
pbrook624f7972008-05-31 16:11:38 +00005741 /* FIXME: This is not threadsafe. */
5742 k = ts->sigtab;
bellard66fb9762003-03-23 01:06:05 +00005743 for(sig = 1; sig <= TARGET_NSIG; sig++) {
5744 if (k->pending)
bellard31e31b82003-02-18 22:55:36 +00005745 goto handle_signal;
bellard66fb9762003-03-23 01:06:05 +00005746 k++;
bellard31e31b82003-02-18 22:55:36 +00005747 }
5748 /* if no signal is pending, just return */
pbrook624f7972008-05-31 16:11:38 +00005749 ts->signal_pending = 0;
bellard31e31b82003-02-18 22:55:36 +00005750 return;
bellard66fb9762003-03-23 01:06:05 +00005751
bellard31e31b82003-02-18 22:55:36 +00005752 handle_signal:
Paolo Bonzinic8ee0a42015-11-13 13:52:21 +01005753 trace_user_handle_signal(cpu_env, sig);
bellard66fb9762003-03-23 01:06:05 +00005754 /* dequeue signal */
5755 q = k->first;
5756 k->first = q->next;
5757 if (!k->first)
5758 k->pending = 0;
ths3b46e622007-09-17 08:09:54 +00005759
Andreas Färberdb6b81d2013-06-27 19:49:31 +02005760 sig = gdb_handlesig(cpu, sig);
bellard1fddef42005-04-17 19:16:13 +00005761 if (!sig) {
aurel32ca587a82008-12-18 22:44:13 +00005762 sa = NULL;
5763 handler = TARGET_SIG_IGN;
5764 } else {
5765 sa = &sigact_table[sig - 1];
5766 handler = sa->_sa_handler;
bellard1fddef42005-04-17 19:16:13 +00005767 }
bellard66fb9762003-03-23 01:06:05 +00005768
Peter Maydella7ec0f92014-03-14 14:36:56 +00005769 if (ts->sigsegv_blocked && sig == TARGET_SIGSEGV) {
5770 /* Guest has blocked SIGSEGV but we got one anyway. Assume this
5771 * is a forced SIGSEGV (ie one the kernel handles via force_sig_info
5772 * because it got a real MMU fault), and treat as if default handler.
5773 */
5774 handler = TARGET_SIG_DFL;
5775 }
5776
bellard66fb9762003-03-23 01:06:05 +00005777 if (handler == TARGET_SIG_DFL) {
aurel32ca587a82008-12-18 22:44:13 +00005778 /* default handler : ignore some signal. The other are job control or fatal */
5779 if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) {
5780 kill(getpid(),SIGSTOP);
5781 } else if (sig != TARGET_SIGCHLD &&
5782 sig != TARGET_SIGURG &&
5783 sig != TARGET_SIGWINCH &&
5784 sig != TARGET_SIGCONT) {
bellard66fb9762003-03-23 01:06:05 +00005785 force_sig(sig);
5786 }
5787 } else if (handler == TARGET_SIG_IGN) {
5788 /* ignore sig */
5789 } else if (handler == TARGET_SIG_ERR) {
5790 force_sig(sig);
5791 } else {
bellard9de5e442003-03-23 16:49:39 +00005792 /* compute the blocked signals during the handler execution */
pbrook624f7972008-05-31 16:11:38 +00005793 target_to_host_sigset(&set, &sa->sa_mask);
bellard9de5e442003-03-23 16:49:39 +00005794 /* SA_NODEFER indicates that the current signal should not be
5795 blocked during the handler */
pbrook624f7972008-05-31 16:11:38 +00005796 if (!(sa->sa_flags & TARGET_SA_NODEFER))
bellard9de5e442003-03-23 16:49:39 +00005797 sigaddset(&set, target_to_host_signal(sig));
ths3b46e622007-09-17 08:09:54 +00005798
bellard9de5e442003-03-23 16:49:39 +00005799 /* block signals in the handler using Linux */
Alex Barcelo1c275922014-03-14 14:36:55 +00005800 do_sigprocmask(SIG_BLOCK, &set, &old_set);
bellard9de5e442003-03-23 16:49:39 +00005801 /* save the previous blocked signal state to restore it at the
5802 end of the signal execution (see do_sigreturn) */
bellard92319442004-06-19 16:58:13 +00005803 host_to_target_sigset_internal(&target_old_set, &old_set);
bellard9de5e442003-03-23 16:49:39 +00005804
bellardbc8a22c2003-03-30 21:02:40 +00005805 /* if the CPU is in VM86 mode, we restore the 32 bit values */
j_mayer84409dd2007-04-06 08:56:50 +00005806#if defined(TARGET_I386) && !defined(TARGET_X86_64)
bellardbc8a22c2003-03-30 21:02:40 +00005807 {
5808 CPUX86State *env = cpu_env;
5809 if (env->eflags & VM_MASK)
5810 save_v86_state(env);
5811 }
5812#endif
bellard9de5e442003-03-23 16:49:39 +00005813 /* prepare the stack frame of the virtual CPU */
Chen Gangd0924a22015-09-12 23:32:30 +08005814#if defined(TARGET_ABI_MIPSN32) || defined(TARGET_ABI_MIPSN64) \
Chen Gangbf0f60a2015-09-27 08:10:18 +08005815 || defined(TARGET_OPENRISC) || defined(TARGET_TILEGX)
Richard Hendersonff970902013-02-10 10:30:42 -08005816 /* These targets do not have traditional signals. */
5817 setup_rt_frame(sig, sa, &q->info, &target_old_set, cpu_env);
5818#else
pbrook624f7972008-05-31 16:11:38 +00005819 if (sa->sa_flags & TARGET_SA_SIGINFO)
5820 setup_rt_frame(sig, sa, &q->info, &target_old_set, cpu_env);
bellard66fb9762003-03-23 01:06:05 +00005821 else
pbrook624f7972008-05-31 16:11:38 +00005822 setup_frame(sig, sa, &target_old_set, cpu_env);
Richard Hendersonff970902013-02-10 10:30:42 -08005823#endif
pbrook624f7972008-05-31 16:11:38 +00005824 if (sa->sa_flags & TARGET_SA_RESETHAND)
5825 sa->_sa_handler = TARGET_SIG_DFL;
bellard31e31b82003-02-18 22:55:36 +00005826 }
bellard66fb9762003-03-23 01:06:05 +00005827 if (q != &k->info)
pbrook624f7972008-05-31 16:11:38 +00005828 free_sigqueue(cpu_env, q);
bellard31e31b82003-02-18 22:55:36 +00005829}