]> git.proxmox.com Git - mirror_qemu.git/blame - linux-user/signal.c
projects / mirror_qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
signal/all: remove return value from copy_siginfo_to_user
[mirror_qemu.git] / linux-user / signal.c
CommitLineData
31e31b8a 1/*
66fb9763 2 * Emulation of Linux signals
5fafdf24 3 *
31e31b8a
FB		 4 * Copyright (c) 2003 Fabrice Bellard
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
8167ee88 17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
31e31b8a
FB		 18 */
19#include <stdlib.h>
20#include <stdio.h>
66fb9763 21#include <string.h>
31e31b8a 22#include <stdarg.h>
2677e107 23#include <unistd.h>
66fb9763 24#include <errno.h>
603e4fd7 25#include <assert.h>
31e31b8a 26#include <sys/ucontext.h>
edf8e2af 27#include <sys/resource.h>
31e31b8a 28
3ef693a0 29#include "qemu.h"
7d99a001 30#include "qemu-common.h"
992f48a0 31#include "target_signal.h"
66fb9763
FB		 32
33//#define DEBUG_SIGNAL
34
249c4c32 35static struct target_sigaltstack target_sigaltstack_used = {
a04e134a
TS		 36 .ss_sp = 0,
37 .ss_size = 0,
38 .ss_flags = TARGET_SS_DISABLE,
39};
40
624f7979 41static struct target_sigaction sigact_table[TARGET_NSIG];
31e31b8a 42
5fafdf24 43static void host_signal_handler(int host_signum, siginfo_t *info,
66fb9763
FB		 44 void *puc);
45
3ca05588 46static uint8_t host_to_target_signal_table[_NSIG] = {
9e5f5284
FB		 47 [SIGHUP] = TARGET_SIGHUP,
48 [SIGINT] = TARGET_SIGINT,
49 [SIGQUIT] = TARGET_SIGQUIT,
50 [SIGILL] = TARGET_SIGILL,
51 [SIGTRAP] = TARGET_SIGTRAP,
52 [SIGABRT] = TARGET_SIGABRT,
01e3b763 53/* [SIGIOT] = TARGET_SIGIOT,*/
9e5f5284
FB		 54 [SIGBUS] = TARGET_SIGBUS,
55 [SIGFPE] = TARGET_SIGFPE,
56 [SIGKILL] = TARGET_SIGKILL,
57 [SIGUSR1] = TARGET_SIGUSR1,
58 [SIGSEGV] = TARGET_SIGSEGV,
59 [SIGUSR2] = TARGET_SIGUSR2,
60 [SIGPIPE] = TARGET_SIGPIPE,
61 [SIGALRM] = TARGET_SIGALRM,
62 [SIGTERM] = TARGET_SIGTERM,
63#ifdef SIGSTKFLT
64 [SIGSTKFLT] = TARGET_SIGSTKFLT,
65#endif
66 [SIGCHLD] = TARGET_SIGCHLD,
67 [SIGCONT] = TARGET_SIGCONT,
68 [SIGSTOP] = TARGET_SIGSTOP,
69 [SIGTSTP] = TARGET_SIGTSTP,
70 [SIGTTIN] = TARGET_SIGTTIN,
71 [SIGTTOU] = TARGET_SIGTTOU,
72 [SIGURG] = TARGET_SIGURG,
73 [SIGXCPU] = TARGET_SIGXCPU,
74 [SIGXFSZ] = TARGET_SIGXFSZ,
75 [SIGVTALRM] = TARGET_SIGVTALRM,
76 [SIGPROF] = TARGET_SIGPROF,
77 [SIGWINCH] = TARGET_SIGWINCH,
78 [SIGIO] = TARGET_SIGIO,
79 [SIGPWR] = TARGET_SIGPWR,
80 [SIGSYS] = TARGET_SIGSYS,
81 /* next signals stay the same */
624f7979 82 /* Nasty hack: Reverse SIGRTMIN and SIGRTMAX to avoid overlap with
b4916d7b 83 host libpthread signals. This assumes no one actually uses SIGRTMAX :-/
624f7979
PB		 84 To fix this properly we need to do manual signal delivery multiplexed
85 over a single host signal. */
86 [__SIGRTMIN] = __SIGRTMAX,
87 [__SIGRTMAX] = __SIGRTMIN,
9e5f5284 88};
3ca05588 89static uint8_t target_to_host_signal_table[_NSIG];
9e5f5284 90
a04e134a
TS		 91static inline int on_sig_stack(unsigned long sp)
92{
93 return (sp - target_sigaltstack_used.ss_sp
94 < target_sigaltstack_used.ss_size);
95}
96
97static inline int sas_ss_flags(unsigned long sp)
98{
99 return (target_sigaltstack_used.ss_size == 0 ? SS_DISABLE
100 : on_sig_stack(sp) ? SS_ONSTACK : 0);
101}
102
1d9d8b55 103int host_to_target_signal(int sig)
31e31b8a 104{
167c50d8 105 if (sig < 0 || sig >= _NSIG)
4cb05961 106 return sig;
9e5f5284 107 return host_to_target_signal_table[sig];
31e31b8a
FB		 108}
109
4cb05961 110int target_to_host_signal(int sig)
31e31b8a 111{
167c50d8 112 if (sig < 0 || sig >= _NSIG)
4cb05961 113 return sig;
9e5f5284 114 return target_to_host_signal_table[sig];
31e31b8a
FB		 115}
116
c227f099 117static inline void target_sigemptyset(target_sigset_t *set)
f5545b5c
PB		 118{
119 memset(set, 0, sizeof(*set));
120}
121
c227f099 122static inline void target_sigaddset(target_sigset_t *set, int signum)
f5545b5c
PB		 123{
124 signum--;
125 abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW);
126 set->sig[signum / TARGET_NSIG_BPW] |= mask;
127}
128
c227f099 129static inline int target_sigismember(const target_sigset_t *set, int signum)
f5545b5c
PB		 130{
131 signum--;
132 abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW);
133 return ((set->sig[signum / TARGET_NSIG_BPW] & mask) != 0);
134}
135
c227f099 136static void host_to_target_sigset_internal(target_sigset_t *d,
9231944d 137 const sigset_t *s)
66fb9763
FB		 138{
139 int i;
f5545b5c
PB		 140 target_sigemptyset(d);
141 for (i = 1; i <= TARGET_NSIG; i++) {
142 if (sigismember(s, i)) {
143 target_sigaddset(d, host_to_target_signal(i));
144 }
66fb9763
FB		 145 }
146}
147
c227f099 148void host_to_target_sigset(target_sigset_t *d, const sigset_t *s)
9231944d 149{
c227f099 150 target_sigset_t d1;
9231944d
FB		 151 int i;
152
153 host_to_target_sigset_internal(&d1, s);
154 for(i = 0;i < TARGET_NSIG_WORDS; i++)
cbb21eed 155 d->sig[i] = tswapal(d1.sig[i]);
9231944d
FB		 156}
157
8fcd3692 158static void target_to_host_sigset_internal(sigset_t *d,
c227f099 159 const target_sigset_t *s)
66fb9763
FB		 160{
161 int i;
f5545b5c
PB		 162 sigemptyset(d);
163 for (i = 1; i <= TARGET_NSIG; i++) {
164 if (target_sigismember(s, i)) {
165 sigaddset(d, target_to_host_signal(i));
166 }
167 }
66fb9763
FB		 168}
169
c227f099 170void target_to_host_sigset(sigset_t *d, const target_sigset_t *s)
9231944d 171{
c227f099 172 target_sigset_t s1;
9231944d
FB		 173 int i;
174
175 for(i = 0;i < TARGET_NSIG_WORDS; i++)
cbb21eed 176 s1.sig[i] = tswapal(s->sig[i]);
9231944d
FB		 177 target_to_host_sigset_internal(d, &s1);
178}
3b46e624 179
992f48a0 180void host_to_target_old_sigset(abi_ulong *old_sigset,
66fb9763
FB		 181 const sigset_t *sigset)
182{
c227f099 183 target_sigset_t d;
9e5f5284
FB		 184 host_to_target_sigset(&d, sigset);
185 *old_sigset = d.sig[0];
66fb9763
FB		 186}
187
5fafdf24 188void target_to_host_old_sigset(sigset_t *sigset,
992f48a0 189 const abi_ulong *old_sigset)
66fb9763 190{
c227f099 191 target_sigset_t d;
9e5f5284
FB		 192 int i;
193
194 d.sig[0] = *old_sigset;
195 for(i = 1;i < TARGET_NSIG_WORDS; i++)
196 d.sig[i] = 0;
197 target_to_host_sigset(sigset, &d);
66fb9763
FB		 198}
199
1c275925
AB		 200/* Wrapper for sigprocmask function
201 * Emulates a sigprocmask in a safe way for the guest. Note that set and oldset
202 * are host signal set, not guest ones. This wraps the sigprocmask host calls
203 * that should be protected (calls originated from guest)
204 */
205int do_sigprocmask(int how, const sigset_t *set, sigset_t *oldset)
206{
a7ec0f98
PM		 207 int ret;
208 sigset_t val;
209 sigset_t *temp = NULL;
210 CPUState *cpu = thread_cpu;
211 TaskState *ts = (TaskState *)cpu->opaque;
212 bool segv_was_blocked = ts->sigsegv_blocked;
213
214 if (set) {
215 bool has_sigsegv = sigismember(set, SIGSEGV);
216 val = *set;
217 temp = &val;
218
219 sigdelset(temp, SIGSEGV);
220
221 switch (how) {
222 case SIG_BLOCK:
223 if (has_sigsegv) {
224 ts->sigsegv_blocked = true;
225 }
226 break;
227 case SIG_UNBLOCK:
228 if (has_sigsegv) {
229 ts->sigsegv_blocked = false;
230 }
231 break;
232 case SIG_SETMASK:
233 ts->sigsegv_blocked = has_sigsegv;
234 break;
235 default:
236 g_assert_not_reached();
237 }
238 }
239
240 ret = sigprocmask(how, temp, oldset);
241
242 if (oldset && segv_was_blocked) {
243 sigaddset(oldset, SIGSEGV);
244 }
245
246 return ret;
1c275925
AB		 247}
248
9de5e440
FB		 249/* siginfo conversion */
250
c227f099 251static inline void host_to_target_siginfo_noswap(target_siginfo_t *tinfo,
9de5e440 252 const siginfo_t *info)
66fb9763 253{
a05c6409 254 int sig = host_to_target_signal(info->si_signo);
9de5e440
FB		 255 tinfo->si_signo = sig;
256 tinfo->si_errno = 0;
afd7cd92 257 tinfo->si_code = info->si_code;
a05c6409
RH		 258
259 if (sig == TARGET_SIGILL || sig == TARGET_SIGFPE || sig == TARGET_SIGSEGV
260 || sig == TARGET_SIGBUS || sig == TARGET_SIGTRAP) {
261 /* Should never come here, but who knows. The information for
262 the target is irrelevant. */
9de5e440 263 tinfo->_sifields._sigfault._addr = 0;
a05c6409
RH		 264 } else if (sig == TARGET_SIGIO) {
265 tinfo->_sifields._sigpoll._band = info->si_band;
7f7f7c84 266 tinfo->_sifields._sigpoll._fd = info->si_fd;
a05c6409
RH		 267 } else if (sig == TARGET_SIGCHLD) {
268 tinfo->_sifields._sigchld._pid = info->si_pid;
269 tinfo->_sifields._sigchld._uid = info->si_uid;
270 tinfo->_sifields._sigchld._status
271 = host_to_target_waitstatus(info->si_status);
272 tinfo->_sifields._sigchld._utime = info->si_utime;
273 tinfo->_sifields._sigchld._stime = info->si_stime;
9de5e440
FB		 274 } else if (sig >= TARGET_SIGRTMIN) {
275 tinfo->_sifields._rt._pid = info->si_pid;
276 tinfo->_sifields._rt._uid = info->si_uid;
277 /* XXX: potential problem if 64 bit */
a05c6409
RH		 278 tinfo->_sifields._rt._sigval.sival_ptr
279 = (abi_ulong)(unsigned long)info->si_value.sival_ptr;
9de5e440
FB		 280 }
281}
282
c227f099
AL		 283static void tswap_siginfo(target_siginfo_t *tinfo,
284 const target_siginfo_t *info)
9de5e440 285{
a05c6409 286 int sig = info->si_signo;
9de5e440 287 tinfo->si_signo = tswap32(sig);
66fb9763
FB		 288 tinfo->si_errno = tswap32(info->si_errno);
289 tinfo->si_code = tswap32(info->si_code);
a05c6409
RH		 290
291 if (sig == TARGET_SIGILL || sig == TARGET_SIGFPE || sig == TARGET_SIGSEGV
292 || sig == TARGET_SIGBUS || sig == TARGET_SIGTRAP) {
293 tinfo->_sifields._sigfault._addr
294 = tswapal(info->_sifields._sigfault._addr);
295 } else if (sig == TARGET_SIGIO) {
296 tinfo->_sifields._sigpoll._band
297 = tswap32(info->_sifields._sigpoll._band);
298 tinfo->_sifields._sigpoll._fd = tswap32(info->_sifields._sigpoll._fd);
299 } else if (sig == TARGET_SIGCHLD) {
300 tinfo->_sifields._sigchld._pid
301 = tswap32(info->_sifields._sigchld._pid);
302 tinfo->_sifields._sigchld._uid
303 = tswap32(info->_sifields._sigchld._uid);
304 tinfo->_sifields._sigchld._status
305 = tswap32(info->_sifields._sigchld._status);
306 tinfo->_sifields._sigchld._utime
307 = tswapal(info->_sifields._sigchld._utime);
308 tinfo->_sifields._sigchld._stime
309 = tswapal(info->_sifields._sigchld._stime);
9de5e440
FB		 310 } else if (sig >= TARGET_SIGRTMIN) {
311 tinfo->_sifields._rt._pid = tswap32(info->_sifields._rt._pid);
312 tinfo->_sifields._rt._uid = tswap32(info->_sifields._rt._uid);
a05c6409
RH		 313 tinfo->_sifields._rt._sigval.sival_ptr
314 = tswapal(info->_sifields._rt._sigval.sival_ptr);
9de5e440
FB		 315 }
316}
317
318
c227f099 319void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info)
9de5e440
FB		 320{
321 host_to_target_siginfo_noswap(tinfo, info);
322 tswap_siginfo(tinfo, tinfo);
66fb9763
FB		 323}
324
9de5e440 325/* XXX: we support only POSIX RT signals are used. */
aa1f17c1 326/* XXX: find a solution for 64 bit (additional malloced data is needed) */
c227f099 327void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo)
66fb9763
FB		 328{
329 info->si_signo = tswap32(tinfo->si_signo);
330 info->si_errno = tswap32(tinfo->si_errno);
331 info->si_code = tswap32(tinfo->si_code);
9de5e440
FB		 332 info->si_pid = tswap32(tinfo->_sifields._rt._pid);
333 info->si_uid = tswap32(tinfo->_sifields._rt._uid);
5fafdf24 334 info->si_value.sival_ptr =
cbb21eed 335 (void *)(long)tswapal(tinfo->_sifields._rt._sigval.sival_ptr);
66fb9763
FB		 336}
337
ca587a8e
AJ		 338static int fatal_signal (int sig)
339{
340 switch (sig) {
341 case TARGET_SIGCHLD:
342 case TARGET_SIGURG:
343 case TARGET_SIGWINCH:
344 /* Ignored by default. */
345 return 0;
346 case TARGET_SIGCONT:
347 case TARGET_SIGSTOP:
348 case TARGET_SIGTSTP:
349 case TARGET_SIGTTIN:
350 case TARGET_SIGTTOU:
351 /* Job control signals. */
352 return 0;
353 default:
354 return 1;
355 }
356}
357
edf8e2af
MW		 358/* returns 1 if given signal should dump core if not handled */
359static int core_dump_signal(int sig)
360{
361 switch (sig) {
362 case TARGET_SIGABRT:
363 case TARGET_SIGFPE:
364 case TARGET_SIGILL:
365 case TARGET_SIGQUIT:
366 case TARGET_SIGSEGV:
367 case TARGET_SIGTRAP:
368 case TARGET_SIGBUS:
369 return (1);
370 default:
371 return (0);
372 }
373}
374
31e31b8a
FB		 375void signal_init(void)
376{
377 struct sigaction act;
624f7979 378 struct sigaction oact;
9e5f5284 379 int i, j;
624f7979 380 int host_sig;
31e31b8a 381
9e5f5284 382 /* generate signal conversion tables */
3ca05588 383 for(i = 1; i < _NSIG; i++) {
9e5f5284
FB		 384 if (host_to_target_signal_table[i] == 0)
385 host_to_target_signal_table[i] = i;
386 }
3ca05588 387 for(i = 1; i < _NSIG; i++) {
9e5f5284
FB		 388 j = host_to_target_signal_table[i];
389 target_to_host_signal_table[j] = i;
390 }
3b46e624 391
9de5e440
FB		 392 /* set all host signal handlers. ALL signals are blocked during
393 the handlers to serialize them. */
624f7979
PB		 394 memset(sigact_table, 0, sizeof(sigact_table));
395
9de5e440 396 sigfillset(&act.sa_mask);
31e31b8a
FB		 397 act.sa_flags = SA_SIGINFO;
398 act.sa_sigaction = host_signal_handler;
624f7979
PB		 399 for(i = 1; i <= TARGET_NSIG; i++) {
400 host_sig = target_to_host_signal(i);
401 sigaction(host_sig, NULL, &oact);
402 if (oact.sa_sigaction == (void *)SIG_IGN) {
403 sigact_table[i - 1]._sa_handler = TARGET_SIG_IGN;
404 } else if (oact.sa_sigaction == (void *)SIG_DFL) {
405 sigact_table[i - 1]._sa_handler = TARGET_SIG_DFL;
406 }
407 /* If there's already a handler installed then something has
408 gone horribly wrong, so don't even try to handle that case. */
ca587a8e
AJ		 409 /* Install some handlers for our own use. We need at least
410 SIGSEGV and SIGBUS, to detect exceptions. We can not just
411 trap all signals because it affects syscall interrupt
412 behavior. But do trap all default-fatal signals. */
413 if (fatal_signal (i))
624f7979 414 sigaction(host_sig, &act, NULL);
31e31b8a 415 }
66fb9763
FB		 416}
417
418/* signal queue handling */
419
9349b4f9 420static inline struct sigqueue *alloc_sigqueue(CPUArchState *env)
66fb9763 421{
0429a971
AF		 422 CPUState *cpu = ENV_GET_CPU(env);
423 TaskState *ts = cpu->opaque;
624f7979 424 struct sigqueue *q = ts->first_free;
66fb9763
FB		 425 if (!q)
426 return NULL;
624f7979 427 ts->first_free = q->next;
66fb9763 428 return q;
31e31b8a
FB		 429}
430
9349b4f9 431static inline void free_sigqueue(CPUArchState *env, struct sigqueue *q)
66fb9763 432{
0429a971
AF		 433 CPUState *cpu = ENV_GET_CPU(env);
434 TaskState *ts = cpu->opaque;
435
624f7979
PB		 436 q->next = ts->first_free;
437 ts->first_free = q;
66fb9763
FB		 438}
439
9de5e440 440/* abort execution with signal */
66393fb9 441static void QEMU_NORETURN force_sig(int target_sig)
66fb9763 442{
0429a971
AF		 443 CPUState *cpu = thread_cpu;
444 CPUArchState *env = cpu->env_ptr;
445 TaskState *ts = (TaskState *)cpu->opaque;
edf8e2af 446 int host_sig, core_dumped = 0;
603e4fd7 447 struct sigaction act;
66393fb9 448 host_sig = target_to_host_signal(target_sig);
a2247f8e 449 gdb_signalled(env, target_sig);
603e4fd7 450
edf8e2af 451 /* dump core if supported by target binary format */
66393fb9 452 if (core_dump_signal(target_sig) && (ts->bprm->core_dump != NULL)) {
edf8e2af
MW		 453 stop_all_tasks();
454 core_dumped =
a2247f8e 455 ((*ts->bprm->core_dump)(target_sig, env) == 0);
edf8e2af
MW		 456 }
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",
66393fb9 465 target_sig, strsignal(host_sig), "core dumped" );
edf8e2af
MW		 466 }
467
0c58751c 468 /* The proper exit code for dying from an uncaught signal is
603e4fd7
AJ		 469 * -<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;
3a5d30bf 476 act.sa_flags = 0;
603e4fd7
AJ		 477 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 */
a6c6f76c 489 abort();
66fb9763
FB		 490}
491
9de5e440
FB		 492/* queue a signal so that it will be send to the virtual CPU as soon
493 as possible */
9349b4f9 494int queue_signal(CPUArchState *env, int sig, target_siginfo_t *info)
31e31b8a 495{
0429a971
AF		 496 CPUState *cpu = ENV_GET_CPU(env);
497 TaskState *ts = cpu->opaque;
624f7979 498 struct emulated_sigtable *k;
9de5e440 499 struct sigqueue *q, **pq;
992f48a0 500 abi_ulong handler;
ca587a8e 501 int queue;
66fb9763 502
9de5e440 503#if defined(DEBUG_SIGNAL)
5fafdf24 504 fprintf(stderr, "queue_signal: sig=%d\n",
9de5e440 505 sig);
66fb9763 506#endif
624f7979 507 k = &ts->sigtab[sig - 1];
ca587a8e 508 queue = gdb_queuesig ();
624f7979 509 handler = sigact_table[sig - 1]._sa_handler;
a7ec0f98
PM		 510
511 if (ts->sigsegv_blocked && sig == TARGET_SIGSEGV) {
512 /* Guest has blocked SIGSEGV but we got one anyway. Assume this
513 * is a forced SIGSEGV (ie one the kernel handles via force_sig_info
514 * because it got a real MMU fault). A blocked SIGSEGV in that
515 * situation is treated as if using the default handler. This is
516 * not correct if some other process has randomly sent us a SIGSEGV
517 * via kill(), but that is not easy to distinguish at this point,
518 * so we assume it doesn't happen.
519 */
520 handler = TARGET_SIG_DFL;
521 }
522
ca587a8e 523 if (!queue && handler == TARGET_SIG_DFL) {
60b19691
TS		 524 if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) {
525 kill(getpid(),SIGSTOP);
526 return 0;
527 } else
66fb9763 528 /* default handler : ignore some signal. The other are fatal */
5fafdf24
TS		 529 if (sig != TARGET_SIGCHLD &&
530 sig != TARGET_SIGURG &&
60b19691
TS		 531 sig != TARGET_SIGWINCH &&
532 sig != TARGET_SIGCONT) {
66fb9763 533 force_sig(sig);
9de5e440
FB		 534 } else {
535 return 0; /* indicate ignored */
66fb9763 536 }
ca587a8e 537 } else if (!queue && handler == TARGET_SIG_IGN) {
66fb9763 538 /* ignore signal */
9de5e440 539 return 0;
ca587a8e 540 } else if (!queue && handler == TARGET_SIG_ERR) {
66fb9763
FB		 541 force_sig(sig);
542 } else {
9de5e440
FB		 543 pq = &k->first;
544 if (sig < TARGET_SIGRTMIN) {
545 /* if non real time signal, we queue exactly one signal */
546 if (!k->pending)
547 q = &k->info;
548 else
549 return 0;
550 } else {
551 if (!k->pending) {
552 /* first signal */
553 q = &k->info;
554 } else {
624f7979 555 q = alloc_sigqueue(env);
9de5e440
FB		 556 if (!q)
557 return -EAGAIN;
558 while (*pq != NULL)
559 pq = &(*pq)->next;
560 }
561 }
562 *pq = q;
563 q->info = *info;
564 q->next = NULL;
565 k->pending = 1;
566 /* signal that a new signal is pending */
624f7979 567 ts->signal_pending = 1;
9de5e440
FB		 568 return 1; /* indicates that the signal was queued */
569 }
570}
571
5fafdf24 572static void host_signal_handler(int host_signum, siginfo_t *info,
9de5e440
FB		 573 void *puc)
574{
a2247f8e 575 CPUArchState *env = thread_cpu->env_ptr;
9de5e440 576 int sig;
c227f099 577 target_siginfo_t tinfo;
9de5e440
FB		 578
579 /* the CPU emulator uses some host signals to detect exceptions,
eaa449b9 580 we forward to it some signals */
ca587a8e 581 if ((host_signum == SIGSEGV || host_signum == SIGBUS)
eaa449b9 582 && info->si_code > 0) {
b346ff46 583 if (cpu_signal_handler(host_signum, info, puc))
9de5e440
FB		 584 return;
585 }
586
587 /* get target signal number */
588 sig = host_to_target_signal(host_signum);
589 if (sig < 1 || sig > TARGET_NSIG)
590 return;
591#if defined(DEBUG_SIGNAL)
bc8a22cc 592 fprintf(stderr, "qemu: got signal %d\n", sig);
9de5e440
FB		 593#endif
594 host_to_target_siginfo_noswap(&tinfo, info);
a2247f8e 595 if (queue_signal(env, sig, &tinfo) == 1) {
9de5e440 596 /* interrupt the virtual CPU as soon as possible */
a2247f8e 597 cpu_exit(thread_cpu);
66fb9763
FB		 598 }
599}
600
0da46a6e 601/* do_sigaltstack() returns target values and errnos. */
579a97f7
FB		 602/* compare linux/kernel/signal.c:do_sigaltstack() */
603abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp)
a04e134a
TS		 604{
605 int ret;
606 struct target_sigaltstack oss;
607
608 /* XXX: test errors */
579a97f7 609 if(uoss_addr)
a04e134a
TS		 610 {
611 __put_user(target_sigaltstack_used.ss_sp, &oss.ss_sp);
612 __put_user(target_sigaltstack_used.ss_size, &oss.ss_size);
613 __put_user(sas_ss_flags(sp), &oss.ss_flags);
614 }
615
579a97f7 616 if(uss_addr)
a04e134a 617 {
579a97f7
FB		 618 struct target_sigaltstack *uss;
619 struct target_sigaltstack ss;
a04e134a 620
0da46a6e 621 ret = -TARGET_EFAULT;
579a97f7 622 if (!lock_user_struct(VERIFY_READ, uss, uss_addr, 1)
a04e134a
TS		 623 || __get_user(ss.ss_sp, &uss->ss_sp)
624 || __get_user(ss.ss_size, &uss->ss_size)
625 || __get_user(ss.ss_flags, &uss->ss_flags))
626 goto out;
579a97f7 627 unlock_user_struct(uss, uss_addr, 0);
a04e134a 628
0da46a6e 629 ret = -TARGET_EPERM;
a04e134a
TS		 630 if (on_sig_stack(sp))
631 goto out;
632
0da46a6e 633 ret = -TARGET_EINVAL;
a04e134a
TS		 634 if (ss.ss_flags != TARGET_SS_DISABLE
635 && ss.ss_flags != TARGET_SS_ONSTACK
636 && ss.ss_flags != 0)
637 goto out;
638
639 if (ss.ss_flags == TARGET_SS_DISABLE) {
640 ss.ss_size = 0;
641 ss.ss_sp = 0;
642 } else {
0da46a6e 643 ret = -TARGET_ENOMEM;
a04e134a
TS		 644 if (ss.ss_size < MINSIGSTKSZ)
645 goto out;
646 }
647
648 target_sigaltstack_used.ss_sp = ss.ss_sp;
649 target_sigaltstack_used.ss_size = ss.ss_size;
650 }
651
579a97f7 652 if (uoss_addr) {
0da46a6e 653 ret = -TARGET_EFAULT;
579a97f7 654 if (copy_to_user(uoss_addr, &oss, sizeof(oss)))
a04e134a 655 goto out;
a04e134a
TS		 656 }
657
658 ret = 0;
659out:
660 return ret;
661}
662
0da46a6e 663/* do_sigaction() return host values and errnos */
66fb9763
FB		 664int do_sigaction(int sig, const struct target_sigaction *act,
665 struct target_sigaction *oact)
666{
624f7979 667 struct target_sigaction *k;
773b93ee
FB		 668 struct sigaction act1;
669 int host_sig;
0da46a6e 670 int ret = 0;
66fb9763 671
2a913eb1 672 if (sig < 1 || sig > TARGET_NSIG || sig == TARGET_SIGKILL || sig == TARGET_SIGSTOP)
66fb9763
FB		 673 return -EINVAL;
674 k = &sigact_table[sig - 1];
773b93ee 675#if defined(DEBUG_SIGNAL)
0bf9e31a
BS		 676 fprintf(stderr, "sigaction sig=%d act=0x%p, oact=0x%p\n",
677 sig, act, oact);
66fb9763
FB		 678#endif
679 if (oact) {
d2565875
RH		 680 __put_user(k->_sa_handler, &oact->_sa_handler);
681 __put_user(k->sa_flags, &oact->sa_flags);
388bb21a 682#if !defined(TARGET_MIPS)
d2565875 683 __put_user(k->sa_restorer, &oact->sa_restorer);
388bb21a 684#endif
d2565875 685 /* Not swapped. */
624f7979 686 oact->sa_mask = k->sa_mask;
66fb9763
FB		 687 }
688 if (act) {
624f7979 689 /* FIXME: This is not threadsafe. */
d2565875
RH		 690 __get_user(k->_sa_handler, &act->_sa_handler);
691 __get_user(k->sa_flags, &act->sa_flags);
388bb21a 692#if !defined(TARGET_MIPS)
d2565875 693 __get_user(k->sa_restorer, &act->sa_restorer);
388bb21a 694#endif
d2565875 695 /* To be swapped in target_to_host_sigset. */
624f7979 696 k->sa_mask = act->sa_mask;
773b93ee
FB		 697
698 /* we update the host linux signal state */
699 host_sig = target_to_host_signal(sig);
700 if (host_sig != SIGSEGV && host_sig != SIGBUS) {
701 sigfillset(&act1.sa_mask);
702 act1.sa_flags = SA_SIGINFO;
624f7979 703 if (k->sa_flags & TARGET_SA_RESTART)
773b93ee
FB		 704 act1.sa_flags |= SA_RESTART;
705 /* NOTE: it is important to update the host kernel signal
706 ignore state to avoid getting unexpected interrupted
707 syscalls */
624f7979 708 if (k->_sa_handler == TARGET_SIG_IGN) {
773b93ee 709 act1.sa_sigaction = (void *)SIG_IGN;
624f7979 710 } else if (k->_sa_handler == TARGET_SIG_DFL) {
ca587a8e
AJ		 711 if (fatal_signal (sig))
712 act1.sa_sigaction = host_signal_handler;
713 else
714 act1.sa_sigaction = (void *)SIG_DFL;
773b93ee
FB		 715 } else {
716 act1.sa_sigaction = host_signal_handler;
717 }
0da46a6e 718 ret = sigaction(host_sig, &act1, NULL);
773b93ee 719 }
66fb9763 720 }
0da46a6e 721 return ret;
66fb9763
FB		 722}
723
b0fd8d18 724static inline void copy_siginfo_to_user(target_siginfo_t *tinfo,
c227f099 725 const target_siginfo_t *info)
43fff238
FB		 726{
727 tswap_siginfo(tinfo, info);
43fff238
FB		 728}
729
c3b5bc8a
TS		 730static inline int current_exec_domain_sig(int sig)
731{
732 return /* current->exec_domain && current->exec_domain->signal_invmap
733 && sig < 32 ? current->exec_domain->signal_invmap[sig] : */ sig;
734}
735
459a4017 736#if defined(TARGET_I386) && TARGET_ABI_BITS == 32
66fb9763
FB		 737
738/* from the Linux kernel */
739
740struct target_fpreg {
741 uint16_t significand[4];
742 uint16_t exponent;
743};
744
745struct target_fpxreg {
746 uint16_t significand[4];
747 uint16_t exponent;
748 uint16_t padding[3];
749};
750
751struct target_xmmreg {
992f48a0 752 abi_ulong element[4];
66fb9763
FB		 753};
754
755struct target_fpstate {
756 /* Regular FPU environment */
992f48a0
BS		 757 abi_ulong cw;
758 abi_ulong sw;
759 abi_ulong tag;
760 abi_ulong ipoff;
761 abi_ulong cssel;
762 abi_ulong dataoff;
763 abi_ulong datasel;
66fb9763
FB		 764 struct target_fpreg _st[8];
765 uint16_t status;
766 uint16_t magic; /* 0xffff = regular FPU data only */
767
768 /* FXSR FPU environment */
992f48a0
BS		 769 abi_ulong _fxsr_env[6]; /* FXSR FPU env is ignored */
770 abi_ulong mxcsr;
771 abi_ulong reserved;
66fb9763
FB		 772 struct target_fpxreg _fxsr_st[8]; /* FXSR FPU reg data is ignored */
773 struct target_xmmreg _xmm[8];
992f48a0 774 abi_ulong padding[56];
66fb9763
FB		 775};
776
777#define X86_FXSR_MAGIC 0x0000
778
779struct target_sigcontext {
780 uint16_t gs, __gsh;
781 uint16_t fs, __fsh;
782 uint16_t es, __esh;
783 uint16_t ds, __dsh;
992f48a0
BS		 784 abi_ulong edi;
785 abi_ulong esi;
786 abi_ulong ebp;
787 abi_ulong esp;
788 abi_ulong ebx;
789 abi_ulong edx;
790 abi_ulong ecx;
791 abi_ulong eax;
792 abi_ulong trapno;
793 abi_ulong err;
794 abi_ulong eip;
66fb9763 795 uint16_t cs, __csh;
992f48a0
BS		 796 abi_ulong eflags;
797 abi_ulong esp_at_signal;
66fb9763 798 uint16_t ss, __ssh;
992f48a0
BS		 799 abi_ulong fpstate; /* pointer */
800 abi_ulong oldmask;
801 abi_ulong cr2;
66fb9763
FB		 802};
803
66fb9763 804struct target_ucontext {
992f48a0
BS		 805 abi_ulong tuc_flags;
806 abi_ulong tuc_link;
c227f099 807 target_stack_t tuc_stack;
b8076a74 808 struct target_sigcontext tuc_mcontext;
c227f099 809 target_sigset_t tuc_sigmask; /* mask last for extensibility */
66fb9763
FB		 810};
811
812struct sigframe
813{
992f48a0 814 abi_ulong pretcode;
66fb9763
FB		 815 int sig;
816 struct target_sigcontext sc;
817 struct target_fpstate fpstate;
992f48a0 818 abi_ulong extramask[TARGET_NSIG_WORDS-1];
66fb9763
FB		 819 char retcode[8];
820};
821
822struct rt_sigframe
823{
992f48a0 824 abi_ulong pretcode;
66fb9763 825 int sig;
992f48a0
BS		 826 abi_ulong pinfo;
827 abi_ulong puc;
66fb9763
FB		 828 struct target_siginfo info;
829 struct target_ucontext uc;
830 struct target_fpstate fpstate;
831 char retcode[8];
832};
833
834/*
835 * Set up a signal frame.
836 */
837
66fb9763
FB		 838/* XXX: save x87 state */
839static int
840setup_sigcontext(struct target_sigcontext *sc, struct target_fpstate *fpstate,
28be6234 841 CPUX86State *env, abi_ulong mask, abi_ulong fpstate_addr)
66fb9763 842{
27103424
AF		 843 CPUState *cs = CPU(x86_env_get_cpu(env));
844 int err = 0;
845 uint16_t magic;
66fb9763 846
579a97f7 847 /* already locked in setup_frame() */
1d8b512b
RV		 848 __put_user(env->segs[R_GS].selector, (unsigned int *)&sc->gs);
849 __put_user(env->segs[R_FS].selector, (unsigned int *)&sc->fs);
850 __put_user(env->segs[R_ES].selector, (unsigned int *)&sc->es);
851 __put_user(env->segs[R_DS].selector, (unsigned int *)&sc->ds);
852 __put_user(env->regs[R_EDI], &sc->edi);
853 __put_user(env->regs[R_ESI], &sc->esi);
854 __put_user(env->regs[R_EBP], &sc->ebp);
855 __put_user(env->regs[R_ESP], &sc->esp);
856 __put_user(env->regs[R_EBX], &sc->ebx);
857 __put_user(env->regs[R_EDX], &sc->edx);
858 __put_user(env->regs[R_ECX], &sc->ecx);
859 __put_user(env->regs[R_EAX], &sc->eax);
860 __put_user(cs->exception_index, &sc->trapno);
861 __put_user(env->error_code, &sc->err);
862 __put_user(env->eip, &sc->eip);
863 __put_user(env->segs[R_CS].selector, (unsigned int *)&sc->cs);
864 __put_user(env->eflags, &sc->eflags);
865 __put_user(env->regs[R_ESP], &sc->esp_at_signal);
866 __put_user(env->segs[R_SS].selector, (unsigned int *)&sc->ss);
ed2dcdf6 867
28be6234 868 cpu_x86_fsave(env, fpstate_addr, 1);
ed2dcdf6 869 fpstate->status = fpstate->sw;
775b58d8 870 magic = 0xffff;
1d8b512b
RV		 871 __put_user(magic, &fpstate->magic);
872 __put_user(fpstate_addr, &sc->fpstate);
ed2dcdf6 873
66fb9763 874 /* non-iBCS2 extensions.. */
1d8b512b
RV		 875 __put_user(mask, &sc->oldmask);
876 __put_user(env->cr[2], &sc->cr2);
66fb9763 877 return err;
31e31b8a
FB		 878}
879
66fb9763
FB		 880/*
881 * Determine which stack to use..
882 */
31e31b8a 883
579a97f7 884static inline abi_ulong
624f7979 885get_sigframe(struct target_sigaction *ka, CPUX86State *env, size_t frame_size)
31e31b8a 886{
66fb9763
FB		 887 unsigned long esp;
888
889 /* Default to using normal stack */
890 esp = env->regs[R_ESP];
66fb9763 891 /* This is the X/Open sanctioned signal stack switching. */
624f7979 892 if (ka->sa_flags & TARGET_SA_ONSTACK) {
a04e134a
TS		 893 if (sas_ss_flags(esp) == 0)
894 esp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
895 }
66fb9763
FB		 896
897 /* This is the legacy signal stack switching. */
5fafdf24 898 else
a52c757c 899 if ((env->segs[R_SS].selector & 0xffff) != __USER_DS &&
624f7979
PB		 900 !(ka->sa_flags & TARGET_SA_RESTORER) &&
901 ka->sa_restorer) {
902 esp = (unsigned long) ka->sa_restorer;
a52c757c 903 }
579a97f7 904 return (esp - frame_size) & -8ul;
66fb9763
FB		 905}
906
579a97f7 907/* compare linux/arch/i386/kernel/signal.c:setup_frame() */
624f7979 908static void setup_frame(int sig, struct target_sigaction *ka,
c227f099 909 target_sigset_t *set, CPUX86State *env)
66fb9763 910{
579a97f7 911 abi_ulong frame_addr;
66fb9763 912 struct sigframe *frame;
7df2fa36 913 int i;
66fb9763 914
579a97f7 915 frame_addr = get_sigframe(ka, env, sizeof(*frame));
66fb9763 916
579a97f7 917 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
66fb9763 918 goto give_sigsegv;
579a97f7 919
1d8b512b
RV		 920 __put_user(current_exec_domain_sig(sig),
921 &frame->sig);
66fb9763 922
28be6234
FB		 923 setup_sigcontext(&frame->sc, &frame->fpstate, env, set->sig[0],
924 frame_addr + offsetof(struct sigframe, fpstate));
66fb9763 925
7df2fa36
RV		 926 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
927 __put_user(set->sig[i], &frame->extramask[i - 1]);
928 }
66fb9763
FB		 929
930 /* Set up to return from userspace. If provided, use a stub
931 already in userspace. */
624f7979 932 if (ka->sa_flags & TARGET_SA_RESTORER) {
1d8b512b 933 __put_user(ka->sa_restorer, &frame->pretcode);
66fb9763 934 } else {
775b58d8 935 uint16_t val16;
28be6234
FB		 936 abi_ulong retcode_addr;
937 retcode_addr = frame_addr + offsetof(struct sigframe, retcode);
1d8b512b 938 __put_user(retcode_addr, &frame->pretcode);
66fb9763 939 /* This is popl %eax ; movl $,%eax ; int $0x80 */
775b58d8 940 val16 = 0xb858;
1d8b512b
RV		 941 __put_user(val16, (uint16_t *)(frame->retcode+0));
942 __put_user(TARGET_NR_sigreturn, (int *)(frame->retcode+2));
775b58d8 943 val16 = 0x80cd;
1d8b512b 944 __put_user(val16, (uint16_t *)(frame->retcode+6));
66fb9763
FB		 945 }
946
66fb9763
FB		 947
948 /* Set up registers for signal handler */
28be6234 949 env->regs[R_ESP] = frame_addr;
624f7979 950 env->eip = ka->_sa_handler;
66fb9763
FB		 951
952 cpu_x86_load_seg(env, R_DS, __USER_DS);
953 cpu_x86_load_seg(env, R_ES, __USER_DS);
954 cpu_x86_load_seg(env, R_SS, __USER_DS);
955 cpu_x86_load_seg(env, R_CS, __USER_CS);
956 env->eflags &= ~TF_MASK;
957
579a97f7
FB		 958 unlock_user_struct(frame, frame_addr, 1);
959
66fb9763
FB		 960 return;
961
962give_sigsegv:
963 if (sig == TARGET_SIGSEGV)
624f7979 964 ka->_sa_handler = TARGET_SIG_DFL;
66fb9763
FB		 965 force_sig(TARGET_SIGSEGV /* , current */);
966}
967
579a97f7 968/* compare linux/arch/i386/kernel/signal.c:setup_rt_frame() */
624f7979 969static void setup_rt_frame(int sig, struct target_sigaction *ka,
c227f099
AL		 970 target_siginfo_t *info,
971 target_sigset_t *set, CPUX86State *env)
66fb9763 972{
28be6234 973 abi_ulong frame_addr, addr;
66fb9763 974 struct rt_sigframe *frame;
9231944d 975 int i, err = 0;
66fb9763 976
579a97f7 977 frame_addr = get_sigframe(ka, env, sizeof(*frame));
66fb9763 978
579a97f7 979 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
66fb9763 980 goto give_sigsegv;
66fb9763 981
1d8b512b 982 __put_user(current_exec_domain_sig(sig), &frame->sig);
28be6234 983 addr = frame_addr + offsetof(struct rt_sigframe, info);
1d8b512b 984 __put_user(addr, &frame->pinfo);
28be6234 985 addr = frame_addr + offsetof(struct rt_sigframe, uc);
1d8b512b 986 __put_user(addr, &frame->puc);
b0fd8d18 987 copy_siginfo_to_user(&frame->info, info);
31e31b8a 988
66fb9763 989 /* Create the ucontext. */
1d8b512b
RV		 990 __put_user(0, &frame->uc.tuc_flags);
991 __put_user(0, &frame->uc.tuc_link);
992 __put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp);
993 __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
994 &frame->uc.tuc_stack.ss_flags);
995 __put_user(target_sigaltstack_used.ss_size,
996 &frame->uc.tuc_stack.ss_size);
b8076a74 997 err |= setup_sigcontext(&frame->uc.tuc_mcontext, &frame->fpstate,
28be6234
FB		 998 env, set->sig[0],
999 frame_addr + offsetof(struct rt_sigframe, fpstate));
9231944d 1000 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
b8076a74 1001 if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
9231944d
FB		 1002 goto give_sigsegv;
1003 }
31e31b8a 1004
66fb9763
FB		 1005 /* Set up to return from userspace. If provided, use a stub
1006 already in userspace. */
624f7979 1007 if (ka->sa_flags & TARGET_SA_RESTORER) {
1d8b512b 1008 __put_user(ka->sa_restorer, &frame->pretcode);
66fb9763 1009 } else {
775b58d8 1010 uint16_t val16;
28be6234 1011 addr = frame_addr + offsetof(struct rt_sigframe, retcode);
1d8b512b 1012 __put_user(addr, &frame->pretcode);
66fb9763 1013 /* This is movl $,%eax ; int $0x80 */
1d8b512b
RV		 1014 __put_user(0xb8, (char *)(frame->retcode+0));
1015 __put_user(TARGET_NR_rt_sigreturn, (int *)(frame->retcode+1));
775b58d8 1016 val16 = 0x80cd;
1d8b512b 1017 __put_user(val16, (uint16_t *)(frame->retcode+5));
66fb9763
FB		 1018 }
1019
1020 if (err)
1021 goto give_sigsegv;
1022
1023 /* Set up registers for signal handler */
28be6234 1024 env->regs[R_ESP] = frame_addr;
624f7979 1025 env->eip = ka->_sa_handler;
66fb9763
FB		 1026
1027 cpu_x86_load_seg(env, R_DS, __USER_DS);
1028 cpu_x86_load_seg(env, R_ES, __USER_DS);
1029 cpu_x86_load_seg(env, R_SS, __USER_DS);
1030 cpu_x86_load_seg(env, R_CS, __USER_CS);
1031 env->eflags &= ~TF_MASK;
1032
579a97f7
FB		 1033 unlock_user_struct(frame, frame_addr, 1);
1034
66fb9763
FB		 1035 return;
1036
1037give_sigsegv:
579a97f7 1038 unlock_user_struct(frame, frame_addr, 1);
66fb9763 1039 if (sig == TARGET_SIGSEGV)
624f7979 1040 ka->_sa_handler = TARGET_SIG_DFL;
66fb9763
FB		 1041 force_sig(TARGET_SIGSEGV /* , current */);
1042}
1043
1044static int
1045restore_sigcontext(CPUX86State *env, struct target_sigcontext *sc, int *peax)
1046{
1047 unsigned int err = 0;
28be6234
FB		 1048 abi_ulong fpstate_addr;
1049 unsigned int tmpflags;
1050
1051 cpu_x86_load_seg(env, R_GS, tswap16(sc->gs));
1052 cpu_x86_load_seg(env, R_FS, tswap16(sc->fs));
1053 cpu_x86_load_seg(env, R_ES, tswap16(sc->es));
1054 cpu_x86_load_seg(env, R_DS, tswap16(sc->ds));
1055
1056 env->regs[R_EDI] = tswapl(sc->edi);
1057 env->regs[R_ESI] = tswapl(sc->esi);
1058 env->regs[R_EBP] = tswapl(sc->ebp);
1059 env->regs[R_ESP] = tswapl(sc->esp);
1060 env->regs[R_EBX] = tswapl(sc->ebx);
1061 env->regs[R_EDX] = tswapl(sc->edx);
1062 env->regs[R_ECX] = tswapl(sc->ecx);
1063 env->eip = tswapl(sc->eip);
66fb9763 1064
9a826d78
MM		 1065 cpu_x86_load_seg(env, R_CS, lduw_p(&sc->cs) | 3);
1066 cpu_x86_load_seg(env, R_SS, lduw_p(&sc->ss) | 3);
5fafdf24 1067
28be6234
FB		 1068 tmpflags = tswapl(sc->eflags);
1069 env->eflags = (env->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);
1070 // regs->orig_eax = -1; /* disable syscall checks */
66fb9763 1071
28be6234
FB		 1072 fpstate_addr = tswapl(sc->fpstate);
1073 if (fpstate_addr != 0) {
1074 if (!access_ok(VERIFY_READ, fpstate_addr,
1075 sizeof(struct target_fpstate)))
1076 goto badframe;
1077 cpu_x86_frstor(env, fpstate_addr, 1);
66fb9763 1078 }
ed2dcdf6 1079
28be6234 1080 *peax = tswapl(sc->eax);
66fb9763 1081 return err;
66fb9763
FB		 1082badframe:
1083 return 1;
66fb9763
FB		 1084}
1085
1086long do_sigreturn(CPUX86State *env)
1087{
579a97f7
FB		 1088 struct sigframe *frame;
1089 abi_ulong frame_addr = env->regs[R_ESP] - 8;
c227f099 1090 target_sigset_t target_set;
66fb9763
FB		 1091 sigset_t set;
1092 int eax, i;
1093
447db213
FB		 1094#if defined(DEBUG_SIGNAL)
1095 fprintf(stderr, "do_sigreturn\n");
1096#endif
579a97f7
FB		 1097 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1098 goto badframe;
66fb9763 1099 /* set blocked signals */
9231944d
FB		 1100 if (__get_user(target_set.sig[0], &frame->sc.oldmask))
1101 goto badframe;
1102 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1103 if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
1104 goto badframe;
1105 }
66fb9763 1106
9231944d 1107 target_to_host_sigset_internal(&set, &target_set);
1c275925 1108 do_sigprocmask(SIG_SETMASK, &set, NULL);
3b46e624 1109
66fb9763
FB		 1110 /* restore registers */
1111 if (restore_sigcontext(env, &frame->sc, &eax))
1112 goto badframe;
579a97f7 1113 unlock_user_struct(frame, frame_addr, 0);
66fb9763
FB		 1114 return eax;
1115
1116badframe:
579a97f7 1117 unlock_user_struct(frame, frame_addr, 0);
66fb9763
FB		 1118 force_sig(TARGET_SIGSEGV);
1119 return 0;
1120}
1121
1122long do_rt_sigreturn(CPUX86State *env)
1123{
28be6234
FB		 1124 abi_ulong frame_addr;
1125 struct rt_sigframe *frame;
66fb9763 1126 sigset_t set;
66fb9763
FB		 1127 int eax;
1128
28be6234
FB		 1129 frame_addr = env->regs[R_ESP] - 4;
1130 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1131 goto badframe;
b8076a74 1132 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
1c275925 1133 do_sigprocmask(SIG_SETMASK, &set, NULL);
5fafdf24 1134
b8076a74 1135 if (restore_sigcontext(env, &frame->uc.tuc_mcontext, &eax))
66fb9763
FB		 1136 goto badframe;
1137
28be6234
FB		 1138 if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe, uc.tuc_stack), 0,
1139 get_sp_from_cpustate(env)) == -EFAULT)
66fb9763 1140 goto badframe;
a04e134a 1141
28be6234 1142 unlock_user_struct(frame, frame_addr, 0);
66fb9763
FB		 1143 return eax;
1144
1145badframe:
28be6234
FB		 1146 unlock_user_struct(frame, frame_addr, 0);
1147 force_sig(TARGET_SIGSEGV);
66fb9763
FB		 1148 return 0;
1149}
1150
1744aea1
AS		 1151#elif defined(TARGET_AARCH64)
1152
1153struct target_sigcontext {
1154 uint64_t fault_address;
1155 /* AArch64 registers */
1156 uint64_t regs[31];
1157 uint64_t sp;
1158 uint64_t pc;
1159 uint64_t pstate;
1160 /* 4K reserved for FP/SIMD state and future expansion */
1161 char __reserved[4096] __attribute__((__aligned__(16)));
1162};
1163
1164struct target_ucontext {
1165 abi_ulong tuc_flags;
1166 abi_ulong tuc_link;
1167 target_stack_t tuc_stack;
1168 target_sigset_t tuc_sigmask;
1169 /* glibc uses a 1024-bit sigset_t */
1170 char __unused[1024 / 8 - sizeof(target_sigset_t)];
1171 /* last for future expansion */
1172 struct target_sigcontext tuc_mcontext;
1173};
1174
1175/*
1176 * Header to be used at the beginning of structures extending the user
1177 * context. Such structures must be placed after the rt_sigframe on the stack
1178 * and be 16-byte aligned. The last structure must be a dummy one with the
1179 * magic and size set to 0.
1180 */
1181struct target_aarch64_ctx {
1182 uint32_t magic;
1183 uint32_t size;
1184};
1185
1186#define TARGET_FPSIMD_MAGIC 0x46508001
1187
1188struct target_fpsimd_context {
1189 struct target_aarch64_ctx head;
1190 uint32_t fpsr;
1191 uint32_t fpcr;
1192 uint64_t vregs[32 * 2]; /* really uint128_t vregs[32] */
1193};
1194
1195/*
1196 * Auxiliary context saved in the sigcontext.__reserved array. Not exported to
1197 * user space as it will change with the addition of new context. User space
1198 * should check the magic/size information.
1199 */
1200struct target_aux_context {
1201 struct target_fpsimd_context fpsimd;
1202 /* additional context to be added before "end" */
1203 struct target_aarch64_ctx end;
1204};
1205
1206struct target_rt_sigframe {
1207 struct target_siginfo info;
1208 struct target_ucontext uc;
1209 uint64_t fp;
1210 uint64_t lr;
1211 uint32_t tramp[2];
1212};
1213
1214static int target_setup_sigframe(struct target_rt_sigframe *sf,
1215 CPUARMState *env, target_sigset_t *set)
1216{
1217 int i;
1218 struct target_aux_context *aux =
1219 (struct target_aux_context *)sf->uc.tuc_mcontext.__reserved;
1220
1221 /* set up the stack frame for unwinding */
1222 __put_user(env->xregs[29], &sf->fp);
1223 __put_user(env->xregs[30], &sf->lr);
1224
1225 for (i = 0; i < 31; i++) {
1226 __put_user(env->xregs[i], &sf->uc.tuc_mcontext.regs[i]);
1227 }
1228 __put_user(env->xregs[31], &sf->uc.tuc_mcontext.sp);
1229 __put_user(env->pc, &sf->uc.tuc_mcontext.pc);
d356312f 1230 __put_user(pstate_read(env), &sf->uc.tuc_mcontext.pstate);
1744aea1 1231
7af03928 1232 __put_user(env->exception.vaddress, &sf->uc.tuc_mcontext.fault_address);
1744aea1
AS		 1233
1234 for (i = 0; i < TARGET_NSIG_WORDS; i++) {
1235 __put_user(set->sig[i], &sf->uc.tuc_sigmask.sig[i]);
1236 }
1237
1238 for (i = 0; i < 32; i++) {
1239#ifdef TARGET_WORDS_BIGENDIAN
1240 __put_user(env->vfp.regs[i * 2], &aux->fpsimd.vregs[i * 2 + 1]);
1241 __put_user(env->vfp.regs[i * 2 + 1], &aux->fpsimd.vregs[i * 2]);
1242#else
1243 __put_user(env->vfp.regs[i * 2], &aux->fpsimd.vregs[i * 2]);
1244 __put_user(env->vfp.regs[i * 2 + 1], &aux->fpsimd.vregs[i * 2 + 1]);
1245#endif
1246 }
e0ee138b
WN		 1247 __put_user(vfp_get_fpsr(env), &aux->fpsimd.fpsr);
1248 __put_user(vfp_get_fpcr(env), &aux->fpsimd.fpcr);
1744aea1
AS		 1249 __put_user(TARGET_FPSIMD_MAGIC, &aux->fpsimd.head.magic);
1250 __put_user(sizeof(struct target_fpsimd_context),
1251 &aux->fpsimd.head.size);
1252
1253 /* set the "end" magic */
1254 __put_user(0, &aux->end.magic);
1255 __put_user(0, &aux->end.size);
1256
1257 return 0;
1258}
1259
1260static int target_restore_sigframe(CPUARMState *env,
1261 struct target_rt_sigframe *sf)
1262{
1263 sigset_t set;
1264 int i;
1265 struct target_aux_context *aux =
1266 (struct target_aux_context *)sf->uc.tuc_mcontext.__reserved;
e0ee138b 1267 uint32_t magic, size, fpsr, fpcr;
d356312f 1268 uint64_t pstate;
1744aea1
AS		 1269
1270 target_to_host_sigset(&set, &sf->uc.tuc_sigmask);
1c275925 1271 do_sigprocmask(SIG_SETMASK, &set, NULL);
1744aea1
AS		 1272
1273 for (i = 0; i < 31; i++) {
1274 __get_user(env->xregs[i], &sf->uc.tuc_mcontext.regs[i]);
1275 }
1276
1277 __get_user(env->xregs[31], &sf->uc.tuc_mcontext.sp);
1278 __get_user(env->pc, &sf->uc.tuc_mcontext.pc);
d356312f
PM		 1279 __get_user(pstate, &sf->uc.tuc_mcontext.pstate);
1280 pstate_write(env, pstate);
1744aea1
AS		 1281
1282 __get_user(magic, &aux->fpsimd.head.magic);
1283 __get_user(size, &aux->fpsimd.head.size);
1284
1285 if (magic != TARGET_FPSIMD_MAGIC
1286 || size != sizeof(struct target_fpsimd_context)) {
1287 return 1;
1288 }
1289
4cf23480
PM		 1290 for (i = 0; i < 32; i++) {
1291#ifdef TARGET_WORDS_BIGENDIAN
1292 __get_user(env->vfp.regs[i * 2], &aux->fpsimd.vregs[i * 2 + 1]);
1293 __get_user(env->vfp.regs[i * 2 + 1], &aux->fpsimd.vregs[i * 2]);
1294#else
1295 __get_user(env->vfp.regs[i * 2], &aux->fpsimd.vregs[i * 2]);
1296 __get_user(env->vfp.regs[i * 2 + 1], &aux->fpsimd.vregs[i * 2 + 1]);
1297#endif
1744aea1 1298 }
e0ee138b
WN		 1299 __get_user(fpsr, &aux->fpsimd.fpsr);
1300 vfp_set_fpsr(env, fpsr);
1301 __get_user(fpcr, &aux->fpsimd.fpcr);
1302 vfp_set_fpcr(env, fpcr);
1744aea1
AS		 1303
1304 return 0;
1305}
1306
1307static abi_ulong get_sigframe(struct target_sigaction *ka, CPUARMState *env)
1308{
1309 abi_ulong sp;
1310
1311 sp = env->xregs[31];
1312
1313 /*
1314 * This is the X/Open sanctioned signal stack switching.
1315 */
1316 if ((ka->sa_flags & SA_ONSTACK) && !sas_ss_flags(sp)) {
1317 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
1318 }
1319
1320 sp = (sp - sizeof(struct target_rt_sigframe)) & ~15;
1321
1322 return sp;
1323}
1324
1325static void target_setup_frame(int usig, struct target_sigaction *ka,
1326 target_siginfo_t *info, target_sigset_t *set,
1327 CPUARMState *env)
1328{
1329 struct target_rt_sigframe *frame;
8a3ae910 1330 abi_ulong frame_addr, return_addr;
1744aea1
AS		 1331
1332 frame_addr = get_sigframe(ka, env);
1333 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
1334 goto give_sigsegv;
1335 }
1336
1337 __put_user(0, &frame->uc.tuc_flags);
1338 __put_user(0, &frame->uc.tuc_link);
1339
1340 __put_user(target_sigaltstack_used.ss_sp,
1341 &frame->uc.tuc_stack.ss_sp);
1342 __put_user(sas_ss_flags(env->xregs[31]),
1343 &frame->uc.tuc_stack.ss_flags);
1344 __put_user(target_sigaltstack_used.ss_size,
1345 &frame->uc.tuc_stack.ss_size);
1346 target_setup_sigframe(frame, env, set);
8a3ae910
MM		 1347 if (ka->sa_flags & TARGET_SA_RESTORER) {
1348 return_addr = ka->sa_restorer;
1349 } else {
1350 /* mov x8,#__NR_rt_sigreturn; svc #0 */
1351 __put_user(0xd2801168, &frame->tramp[0]);
1352 __put_user(0xd4000001, &frame->tramp[1]);
1353 return_addr = frame_addr + offsetof(struct target_rt_sigframe, tramp);
1354 }
1744aea1
AS		 1355 env->xregs[0] = usig;
1356 env->xregs[31] = frame_addr;
1357 env->xregs[29] = env->xregs[31] + offsetof(struct target_rt_sigframe, fp);
1358 env->pc = ka->_sa_handler;
8a3ae910 1359 env->xregs[30] = return_addr;
1744aea1 1360 if (info) {
b0fd8d18 1361 copy_siginfo_to_user(&frame->info, info);
1744aea1
AS		 1362 env->xregs[1] = frame_addr + offsetof(struct target_rt_sigframe, info);
1363 env->xregs[2] = frame_addr + offsetof(struct target_rt_sigframe, uc);
1364 }
1365
1366 unlock_user_struct(frame, frame_addr, 1);
1367 return;
1368
1369 give_sigsegv:
1370 unlock_user_struct(frame, frame_addr, 1);
1371 force_sig(TARGET_SIGSEGV);
1372}
1373
1374static void setup_rt_frame(int sig, struct target_sigaction *ka,
1375 target_siginfo_t *info, target_sigset_t *set,
1376 CPUARMState *env)
1377{
1378 target_setup_frame(sig, ka, info, set, env);
1379}
1380
1381static void setup_frame(int sig, struct target_sigaction *ka,
1382 target_sigset_t *set, CPUARMState *env)
1383{
1384 target_setup_frame(sig, ka, 0, set, env);
1385}
1386
1387long do_rt_sigreturn(CPUARMState *env)
1388{
7f72cd23 1389 struct target_rt_sigframe *frame = NULL;
1744aea1
AS		 1390 abi_ulong frame_addr = env->xregs[31];
1391
1392 if (frame_addr & 15) {
1393 goto badframe;
1394 }
1395
1396 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
1397 goto badframe;
1398 }
1399
1400 if (target_restore_sigframe(env, frame)) {
1401 goto badframe;
1402 }
1403
1404 if (do_sigaltstack(frame_addr +
1405 offsetof(struct target_rt_sigframe, uc.tuc_stack),
1406 0, get_sp_from_cpustate(env)) == -EFAULT) {
1407 goto badframe;
1408 }
1409
1410 unlock_user_struct(frame, frame_addr, 0);
1411 return env->xregs[0];
1412
1413 badframe:
1414 unlock_user_struct(frame, frame_addr, 0);
1415 force_sig(TARGET_SIGSEGV);
1416 return 0;
1417}
1418
1419long do_sigreturn(CPUARMState *env)
1420{
1421 return do_rt_sigreturn(env);
1422}
1423
43fff238
FB		 1424#elif defined(TARGET_ARM)
1425
1426struct target_sigcontext {
992f48a0
BS		 1427 abi_ulong trap_no;
1428 abi_ulong error_code;
1429 abi_ulong oldmask;
1430 abi_ulong arm_r0;
1431 abi_ulong arm_r1;
1432 abi_ulong arm_r2;
1433 abi_ulong arm_r3;
1434 abi_ulong arm_r4;
1435 abi_ulong arm_r5;
1436 abi_ulong arm_r6;
1437 abi_ulong arm_r7;
1438 abi_ulong arm_r8;
1439 abi_ulong arm_r9;
1440 abi_ulong arm_r10;
1441 abi_ulong arm_fp;
1442 abi_ulong arm_ip;
1443 abi_ulong arm_sp;
1444 abi_ulong arm_lr;
1445 abi_ulong arm_pc;
1446 abi_ulong arm_cpsr;
1447 abi_ulong fault_address;
43fff238
FB		 1448};
1449
a745ec6d
PB		 1450struct target_ucontext_v1 {
1451 abi_ulong tuc_flags;
1452 abi_ulong tuc_link;
c227f099 1453 target_stack_t tuc_stack;
a745ec6d 1454 struct target_sigcontext tuc_mcontext;
c227f099 1455 target_sigset_t tuc_sigmask; /* mask last for extensibility */
a745ec6d
PB		 1456};
1457
1458struct target_ucontext_v2 {
992f48a0
BS		 1459 abi_ulong tuc_flags;
1460 abi_ulong tuc_link;
c227f099 1461 target_stack_t tuc_stack;
b8076a74 1462 struct target_sigcontext tuc_mcontext;
c227f099 1463 target_sigset_t tuc_sigmask; /* mask last for extensibility */
5f0b7c88 1464 char __unused[128 - sizeof(target_sigset_t)];
a745ec6d 1465 abi_ulong tuc_regspace[128] __attribute__((__aligned__(8)));
43fff238
FB		 1466};
1467
0d871bdb
PM		 1468struct target_user_vfp {
1469 uint64_t fpregs[32];
1470 abi_ulong fpscr;
1471};
1472
1473struct target_user_vfp_exc {
1474 abi_ulong fpexc;
1475 abi_ulong fpinst;
1476 abi_ulong fpinst2;
1477};
1478
1479struct target_vfp_sigframe {
1480 abi_ulong magic;
1481 abi_ulong size;
1482 struct target_user_vfp ufp;
1483 struct target_user_vfp_exc ufp_exc;
1484} __attribute__((__aligned__(8)));
1485
08e11256
PM		 1486struct target_iwmmxt_sigframe {
1487 abi_ulong magic;
1488 abi_ulong size;
1489 uint64_t regs[16];
1490 /* Note that not all the coprocessor control registers are stored here */
1491 uint32_t wcssf;
1492 uint32_t wcasf;
1493 uint32_t wcgr0;
1494 uint32_t wcgr1;
1495 uint32_t wcgr2;
1496 uint32_t wcgr3;
1497} __attribute__((__aligned__(8)));
1498
0d871bdb 1499#define TARGET_VFP_MAGIC 0x56465001
08e11256 1500#define TARGET_IWMMXT_MAGIC 0x12ef842a
0d871bdb 1501
a8c33204 1502struct sigframe_v1
43fff238
FB		 1503{
1504 struct target_sigcontext sc;
992f48a0
BS		 1505 abi_ulong extramask[TARGET_NSIG_WORDS-1];
1506 abi_ulong retcode;
43fff238
FB		 1507};
1508
a8c33204
PB		 1509struct sigframe_v2
1510{
1511 struct target_ucontext_v2 uc;
1512 abi_ulong retcode;
1513};
1514
a745ec6d 1515struct rt_sigframe_v1
43fff238 1516{
f8b0aa25
FB		 1517 abi_ulong pinfo;
1518 abi_ulong puc;
43fff238 1519 struct target_siginfo info;
a745ec6d
PB		 1520 struct target_ucontext_v1 uc;
1521 abi_ulong retcode;
1522};
1523
1524struct rt_sigframe_v2
1525{
1526 struct target_siginfo info;
1527 struct target_ucontext_v2 uc;
992f48a0 1528 abi_ulong retcode;
43fff238
FB		 1529};
1530
1531#define TARGET_CONFIG_CPU_32 1
1532
1533/*
1534 * For ARM syscalls, we encode the syscall number into the instruction.
1535 */
1536#define SWI_SYS_SIGRETURN (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE))
1537#define SWI_SYS_RT_SIGRETURN (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE))
1538
1539/*
1540 * For Thumb syscalls, we pass the syscall number via r7. We therefore
1541 * need two 16-bit instructions.
1542 */
1543#define SWI_THUMB_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn))
1544#define SWI_THUMB_RT_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn))
1545
992f48a0 1546static const abi_ulong retcodes[4] = {
43fff238
FB		 1547 SWI_SYS_SIGRETURN, SWI_THUMB_SIGRETURN,
1548 SWI_SYS_RT_SIGRETURN, SWI_THUMB_RT_SIGRETURN
1549};
1550
1551
05390248 1552static inline int valid_user_regs(CPUARMState *regs)
43fff238
FB		 1553{
1554 return 1;
1555}
1556
a8c33204 1557static void
43fff238 1558setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
05390248 1559 CPUARMState *env, abi_ulong mask)
43fff238 1560{
a8c33204
PB		 1561 __put_user(env->regs[0], &sc->arm_r0);
1562 __put_user(env->regs[1], &sc->arm_r1);
1563 __put_user(env->regs[2], &sc->arm_r2);
1564 __put_user(env->regs[3], &sc->arm_r3);
1565 __put_user(env->regs[4], &sc->arm_r4);
1566 __put_user(env->regs[5], &sc->arm_r5);
1567 __put_user(env->regs[6], &sc->arm_r6);
1568 __put_user(env->regs[7], &sc->arm_r7);
1569 __put_user(env->regs[8], &sc->arm_r8);
1570 __put_user(env->regs[9], &sc->arm_r9);
1571 __put_user(env->regs[10], &sc->arm_r10);
1572 __put_user(env->regs[11], &sc->arm_fp);
1573 __put_user(env->regs[12], &sc->arm_ip);
1574 __put_user(env->regs[13], &sc->arm_sp);
1575 __put_user(env->regs[14], &sc->arm_lr);
1576 __put_user(env->regs[15], &sc->arm_pc);
43fff238 1577#ifdef TARGET_CONFIG_CPU_32
a8c33204 1578 __put_user(cpsr_read(env), &sc->arm_cpsr);
43fff238
FB		 1579#endif
1580
a8c33204
PB		 1581 __put_user(/* current->thread.trap_no */ 0, &sc->trap_no);
1582 __put_user(/* current->thread.error_code */ 0, &sc->error_code);
1583 __put_user(/* current->thread.address */ 0, &sc->fault_address);
1584 __put_user(mask, &sc->oldmask);
43fff238
FB		 1585}
1586
579a97f7 1587static inline abi_ulong
05390248 1588get_sigframe(struct target_sigaction *ka, CPUARMState *regs, int framesize)
43fff238
FB		 1589{
1590 unsigned long sp = regs->regs[13];
1591
43fff238
FB		 1592 /*
1593 * This is the X/Open sanctioned signal stack switching.
1594 */
624f7979 1595 if ((ka->sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp))
a04e134a 1596 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
43fff238
FB		 1597 /*
1598 * ATPCS B01 mandates 8-byte alignment
1599 */
579a97f7 1600 return (sp - framesize) & ~7;
43fff238
FB		 1601}
1602
1603static int
05390248 1604setup_return(CPUARMState *env, struct target_sigaction *ka,
f8b0aa25 1605 abi_ulong *rc, abi_ulong frame_addr, int usig, abi_ulong rc_addr)
43fff238 1606{
624f7979 1607 abi_ulong handler = ka->_sa_handler;
992f48a0 1608 abi_ulong retcode;
75b680e5 1609 int thumb = handler & 1;
964413d9
PM		 1610 uint32_t cpsr = cpsr_read(env);
1611
1612 cpsr &= ~CPSR_IT;
1613 if (thumb) {
1614 cpsr |= CPSR_T;
1615 } else {
1616 cpsr &= ~CPSR_T;
1617 }
43fff238 1618
624f7979
PB		 1619 if (ka->sa_flags & TARGET_SA_RESTORER) {
1620 retcode = ka->sa_restorer;
43fff238
FB		 1621 } else {
1622 unsigned int idx = thumb;
1623
624f7979 1624 if (ka->sa_flags & TARGET_SA_SIGINFO)
43fff238
FB		 1625 idx += 2;
1626
1627 if (__put_user(retcodes[idx], rc))
1628 return 1;
ca8a277c 1629
f8b0aa25 1630 retcode = rc_addr + thumb;
43fff238
FB		 1631 }
1632
1633 env->regs[0] = usig;
f8b0aa25 1634 env->regs[13] = frame_addr;
43fff238
FB		 1635 env->regs[14] = retcode;
1636 env->regs[15] = handler & (thumb ? ~1 : ~3);
964413d9 1637 cpsr_write(env, cpsr, 0xffffffff);
43fff238
FB		 1638
1639 return 0;
1640}
1641
05390248 1642static abi_ulong *setup_sigframe_v2_vfp(abi_ulong *regspace, CPUARMState *env)
0d871bdb
PM		 1643{
1644 int i;
1645 struct target_vfp_sigframe *vfpframe;
1646 vfpframe = (struct target_vfp_sigframe *)regspace;
1647 __put_user(TARGET_VFP_MAGIC, &vfpframe->magic);
1648 __put_user(sizeof(*vfpframe), &vfpframe->size);
1649 for (i = 0; i < 32; i++) {
005e1a0a 1650 __put_user(float64_val(env->vfp.regs[i]), &vfpframe->ufp.fpregs[i]);
0d871bdb
PM		 1651 }
1652 __put_user(vfp_get_fpscr(env), &vfpframe->ufp.fpscr);
1653 __put_user(env->vfp.xregs[ARM_VFP_FPEXC], &vfpframe->ufp_exc.fpexc);
1654 __put_user(env->vfp.xregs[ARM_VFP_FPINST], &vfpframe->ufp_exc.fpinst);
1655 __put_user(env->vfp.xregs[ARM_VFP_FPINST2], &vfpframe->ufp_exc.fpinst2);
1656 return (abi_ulong*)(vfpframe+1);
1657}
1658
05390248
AF		 1659static abi_ulong *setup_sigframe_v2_iwmmxt(abi_ulong *regspace,
1660 CPUARMState *env)
08e11256
PM		 1661{
1662 int i;
1663 struct target_iwmmxt_sigframe *iwmmxtframe;
1664 iwmmxtframe = (struct target_iwmmxt_sigframe *)regspace;
1665 __put_user(TARGET_IWMMXT_MAGIC, &iwmmxtframe->magic);
1666 __put_user(sizeof(*iwmmxtframe), &iwmmxtframe->size);
1667 for (i = 0; i < 16; i++) {
1668 __put_user(env->iwmmxt.regs[i], &iwmmxtframe->regs[i]);
1669 }
1670 __put_user(env->vfp.xregs[ARM_IWMMXT_wCSSF], &iwmmxtframe->wcssf);
1671 __put_user(env->vfp.xregs[ARM_IWMMXT_wCASF], &iwmmxtframe->wcssf);
1672 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR0], &iwmmxtframe->wcgr0);
1673 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR1], &iwmmxtframe->wcgr1);
1674 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR2], &iwmmxtframe->wcgr2);
1675 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR3], &iwmmxtframe->wcgr3);
1676 return (abi_ulong*)(iwmmxtframe+1);
1677}
1678
a8c33204 1679static void setup_sigframe_v2(struct target_ucontext_v2 *uc,
05390248 1680 target_sigset_t *set, CPUARMState *env)
a8c33204
PB		 1681{
1682 struct target_sigaltstack stack;
1683 int i;
0d871bdb 1684 abi_ulong *regspace;
a8c33204
PB		 1685
1686 /* Clear all the bits of the ucontext we don't use. */
1687 memset(uc, 0, offsetof(struct target_ucontext_v2, tuc_mcontext));
1688
1689 memset(&stack, 0, sizeof(stack));
1690 __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp);
1691 __put_user(target_sigaltstack_used.ss_size, &stack.ss_size);
1692 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags);
1693 memcpy(&uc->tuc_stack, &stack, sizeof(stack));
1694
1695 setup_sigcontext(&uc->tuc_mcontext, env, set->sig[0]);
0d871bdb
PM		 1696 /* Save coprocessor signal frame. */
1697 regspace = uc->tuc_regspace;
1698 if (arm_feature(env, ARM_FEATURE_VFP)) {
1699 regspace = setup_sigframe_v2_vfp(regspace, env);
1700 }
08e11256
PM		 1701 if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
1702 regspace = setup_sigframe_v2_iwmmxt(regspace, env);
1703 }
1704
0d871bdb
PM		 1705 /* Write terminating magic word */
1706 __put_user(0, regspace);
1707
a8c33204
PB		 1708 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1709 __put_user(set->sig[i], &uc->tuc_sigmask.sig[i]);
1710 }
1711}
1712
579a97f7 1713/* compare linux/arch/arm/kernel/signal.c:setup_frame() */
624f7979 1714static void setup_frame_v1(int usig, struct target_sigaction *ka,
05390248 1715 target_sigset_t *set, CPUARMState *regs)
43fff238 1716{
a8c33204 1717 struct sigframe_v1 *frame;
579a97f7 1718 abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
a8c33204 1719 int i;
43fff238 1720
579a97f7
FB		 1721 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1722 return;
1723
a8c33204 1724 setup_sigcontext(&frame->sc, regs, set->sig[0]);
43fff238 1725
9231944d
FB		 1726 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1727 if (__put_user(set->sig[i], &frame->extramask[i - 1]))
579a97f7 1728 goto end;
43fff238
FB		 1729 }
1730
a8c33204
PB		 1731 setup_return(regs, ka, &frame->retcode, frame_addr, usig,
1732 frame_addr + offsetof(struct sigframe_v1, retcode));
579a97f7
FB		 1733
1734end:
1735 unlock_user_struct(frame, frame_addr, 1);
a8c33204
PB		 1736}
1737
624f7979 1738static void setup_frame_v2(int usig, struct target_sigaction *ka,
05390248 1739 target_sigset_t *set, CPUARMState *regs)
a8c33204
PB		 1740{
1741 struct sigframe_v2 *frame;
1742 abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
1743
1744 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1745 return;
1746
1747 setup_sigframe_v2(&frame->uc, set, regs);
1748
1749 setup_return(regs, ka, &frame->retcode, frame_addr, usig,
1750 frame_addr + offsetof(struct sigframe_v2, retcode));
1751
1752 unlock_user_struct(frame, frame_addr, 1);
1753}
1754
624f7979 1755static void setup_frame(int usig, struct target_sigaction *ka,
05390248 1756 target_sigset_t *set, CPUARMState *regs)
a8c33204
PB		 1757{
1758 if (get_osversion() >= 0x020612) {
1759 setup_frame_v2(usig, ka, set, regs);
1760 } else {
1761 setup_frame_v1(usig, ka, set, regs);
1762 }
43fff238
FB		 1763}
1764
579a97f7 1765/* compare linux/arch/arm/kernel/signal.c:setup_rt_frame() */
624f7979 1766static void setup_rt_frame_v1(int usig, struct target_sigaction *ka,
c227f099 1767 target_siginfo_t *info,
05390248 1768 target_sigset_t *set, CPUARMState *env)
43fff238 1769{
a745ec6d 1770 struct rt_sigframe_v1 *frame;
579a97f7 1771 abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
a04e134a 1772 struct target_sigaltstack stack;
a8c33204 1773 int i;
f8b0aa25 1774 abi_ulong info_addr, uc_addr;
43fff238 1775
579a97f7 1776 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
edf779ff
FB		 1777 return /* 1 */;
1778
a745ec6d 1779 info_addr = frame_addr + offsetof(struct rt_sigframe_v1, info);
a8c33204 1780 __put_user(info_addr, &frame->pinfo);
a745ec6d 1781 uc_addr = frame_addr + offsetof(struct rt_sigframe_v1, uc);
a8c33204
PB		 1782 __put_user(uc_addr, &frame->puc);
1783 copy_siginfo_to_user(&frame->info, info);
43fff238
FB		 1784
1785 /* Clear all the bits of the ucontext we don't use. */
a745ec6d 1786 memset(&frame->uc, 0, offsetof(struct target_ucontext_v1, tuc_mcontext));
43fff238 1787
a04e134a
TS		 1788 memset(&stack, 0, sizeof(stack));
1789 __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp);
1790 __put_user(target_sigaltstack_used.ss_size, &stack.ss_size);
1791 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags);
775b58d8 1792 memcpy(&frame->uc.tuc_stack, &stack, sizeof(stack));
a04e134a 1793
a8c33204 1794 setup_sigcontext(&frame->uc.tuc_mcontext, env, set->sig[0]);
9231944d 1795 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
b8076a74 1796 if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
579a97f7 1797 goto end;
9231944d 1798 }
43fff238 1799
a8c33204
PB		 1800 setup_return(env, ka, &frame->retcode, frame_addr, usig,
1801 frame_addr + offsetof(struct rt_sigframe_v1, retcode));
a745ec6d 1802
a8c33204
PB		 1803 env->regs[1] = info_addr;
1804 env->regs[2] = uc_addr;
a745ec6d
PB		 1805
1806end:
1807 unlock_user_struct(frame, frame_addr, 1);
a745ec6d
PB		 1808}
1809
624f7979 1810static void setup_rt_frame_v2(int usig, struct target_sigaction *ka,
c227f099 1811 target_siginfo_t *info,
05390248 1812 target_sigset_t *set, CPUARMState *env)
a745ec6d
PB		 1813{
1814 struct rt_sigframe_v2 *frame;
1815 abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
a745ec6d
PB		 1816 abi_ulong info_addr, uc_addr;
1817
1818 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1819 return /* 1 */;
1820
1821 info_addr = frame_addr + offsetof(struct rt_sigframe_v2, info);
1822 uc_addr = frame_addr + offsetof(struct rt_sigframe_v2, uc);
a8c33204 1823 copy_siginfo_to_user(&frame->info, info);
a745ec6d 1824
a8c33204 1825 setup_sigframe_v2(&frame->uc, set, env);
a745ec6d 1826
a8c33204
PB		 1827 setup_return(env, ka, &frame->retcode, frame_addr, usig,
1828 frame_addr + offsetof(struct rt_sigframe_v2, retcode));
a745ec6d 1829
a8c33204
PB		 1830 env->regs[1] = info_addr;
1831 env->regs[2] = uc_addr;
43fff238 1832
579a97f7 1833 unlock_user_struct(frame, frame_addr, 1);
43fff238
FB		 1834}
1835
624f7979 1836static void setup_rt_frame(int usig, struct target_sigaction *ka,
c227f099 1837 target_siginfo_t *info,
05390248 1838 target_sigset_t *set, CPUARMState *env)
a745ec6d
PB		 1839{
1840 if (get_osversion() >= 0x020612) {
1841 setup_rt_frame_v2(usig, ka, info, set, env);
1842 } else {
1843 setup_rt_frame_v1(usig, ka, info, set, env);
1844 }
1845}
1846
43fff238 1847static int
05390248 1848restore_sigcontext(CPUARMState *env, struct target_sigcontext *sc)
43fff238
FB		 1849{
1850 int err = 0;
b5ff1b31 1851 uint32_t cpsr;
43fff238 1852
1d8b512b
RV		 1853 __get_user(env->regs[0], &sc->arm_r0);
1854 __get_user(env->regs[1], &sc->arm_r1);
1855 __get_user(env->regs[2], &sc->arm_r2);
1856 __get_user(env->regs[3], &sc->arm_r3);
1857 __get_user(env->regs[4], &sc->arm_r4);
1858 __get_user(env->regs[5], &sc->arm_r5);
1859 __get_user(env->regs[6], &sc->arm_r6);
1860 __get_user(env->regs[7], &sc->arm_r7);
1861 __get_user(env->regs[8], &sc->arm_r8);
1862 __get_user(env->regs[9], &sc->arm_r9);
1863 __get_user(env->regs[10], &sc->arm_r10);
1864 __get_user(env->regs[11], &sc->arm_fp);
1865 __get_user(env->regs[12], &sc->arm_ip);
1866 __get_user(env->regs[13], &sc->arm_sp);
1867 __get_user(env->regs[14], &sc->arm_lr);
1868 __get_user(env->regs[15], &sc->arm_pc);
43fff238 1869#ifdef TARGET_CONFIG_CPU_32
1d8b512b 1870 __get_user(cpsr, &sc->arm_cpsr);
75b680e5 1871 cpsr_write(env, cpsr, CPSR_USER | CPSR_EXEC);
43fff238
FB		 1872#endif
1873
1874 err |= !valid_user_regs(env);
1875
1876 return err;
1877}
1878
05390248 1879static long do_sigreturn_v1(CPUARMState *env)
43fff238 1880{
f8b0aa25 1881 abi_ulong frame_addr;
978fae9f 1882 struct sigframe_v1 *frame = NULL;
c227f099 1883 target_sigset_t set;
43fff238 1884 sigset_t host_set;
9231944d 1885 int i;
43fff238
FB		 1886
1887 /*
1888 * Since we stacked the signal on a 64-bit boundary,
1889 * then 'sp' should be word aligned here. If it's
1890 * not, then the user is trying to mess with us.
1891 */
f8b0aa25 1892 frame_addr = env->regs[13];
978fae9f
PM		 1893 if (frame_addr & 7) {
1894 goto badframe;
1895 }
1896
f8b0aa25
FB		 1897 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1898 goto badframe;
43fff238 1899
9231944d
FB		 1900 if (__get_user(set.sig[0], &frame->sc.oldmask))
1901 goto badframe;
1902 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1903 if (__get_user(set.sig[i], &frame->extramask[i - 1]))
1904 goto badframe;
1905 }
43fff238 1906
9231944d 1907 target_to_host_sigset_internal(&host_set, &set);
1c275925 1908 do_sigprocmask(SIG_SETMASK, &host_set, NULL);
43fff238
FB		 1909
1910 if (restore_sigcontext(env, &frame->sc))
1911 goto badframe;
1912
1913#if 0
1914 /* Send SIGTRAP if we're single-stepping */
1915 if (ptrace_cancel_bpt(current))
1916 send_sig(SIGTRAP, current, 1);
1917#endif
f8b0aa25
FB		 1918 unlock_user_struct(frame, frame_addr, 0);
1919 return env->regs[0];
43fff238
FB		 1920
1921badframe:
f8b0aa25 1922 unlock_user_struct(frame, frame_addr, 0);
66393fb9 1923 force_sig(TARGET_SIGSEGV /* , current */);
43fff238
FB		 1924 return 0;
1925}
1926
05390248 1927static abi_ulong *restore_sigframe_v2_vfp(CPUARMState *env, abi_ulong *regspace)
5f9099d9
PM		 1928{
1929 int i;
1930 abi_ulong magic, sz;
1931 uint32_t fpscr, fpexc;
1932 struct target_vfp_sigframe *vfpframe;
1933 vfpframe = (struct target_vfp_sigframe *)regspace;
1934
1935 __get_user(magic, &vfpframe->magic);
1936 __get_user(sz, &vfpframe->size);
1937 if (magic != TARGET_VFP_MAGIC || sz != sizeof(*vfpframe)) {
1938 return 0;
1939 }
1940 for (i = 0; i < 32; i++) {
005e1a0a 1941 __get_user(float64_val(env->vfp.regs[i]), &vfpframe->ufp.fpregs[i]);
5f9099d9
PM		 1942 }
1943 __get_user(fpscr, &vfpframe->ufp.fpscr);
1944 vfp_set_fpscr(env, fpscr);
1945 __get_user(fpexc, &vfpframe->ufp_exc.fpexc);
1946 /* Sanitise FPEXC: ensure VFP is enabled, FPINST2 is invalid
1947 * and the exception flag is cleared
1948 */
1949 fpexc |= (1 << 30);
1950 fpexc &= ~((1 << 31) | (1 << 28));
1951 env->vfp.xregs[ARM_VFP_FPEXC] = fpexc;
1952 __get_user(env->vfp.xregs[ARM_VFP_FPINST], &vfpframe->ufp_exc.fpinst);
1953 __get_user(env->vfp.xregs[ARM_VFP_FPINST2], &vfpframe->ufp_exc.fpinst2);
1954 return (abi_ulong*)(vfpframe + 1);
1955}
1956
05390248
AF		 1957static abi_ulong *restore_sigframe_v2_iwmmxt(CPUARMState *env,
1958 abi_ulong *regspace)
a59d69da
PM		 1959{
1960 int i;
1961 abi_ulong magic, sz;
1962 struct target_iwmmxt_sigframe *iwmmxtframe;
1963 iwmmxtframe = (struct target_iwmmxt_sigframe *)regspace;
1964
1965 __get_user(magic, &iwmmxtframe->magic);
1966 __get_user(sz, &iwmmxtframe->size);
1967 if (magic != TARGET_IWMMXT_MAGIC || sz != sizeof(*iwmmxtframe)) {
1968 return 0;
1969 }
1970 for (i = 0; i < 16; i++) {
1971 __get_user(env->iwmmxt.regs[i], &iwmmxtframe->regs[i]);
1972 }
1973 __get_user(env->vfp.xregs[ARM_IWMMXT_wCSSF], &iwmmxtframe->wcssf);
1974 __get_user(env->vfp.xregs[ARM_IWMMXT_wCASF], &iwmmxtframe->wcssf);
1975 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR0], &iwmmxtframe->wcgr0);
1976 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR1], &iwmmxtframe->wcgr1);
1977 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR2], &iwmmxtframe->wcgr2);
1978 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR3], &iwmmxtframe->wcgr3);
1979 return (abi_ulong*)(iwmmxtframe + 1);
1980}
1981
05390248 1982static int do_sigframe_return_v2(CPUARMState *env, target_ulong frame_addr,
a8c33204
PB		 1983 struct target_ucontext_v2 *uc)
1984{
1985 sigset_t host_set;
5f9099d9 1986 abi_ulong *regspace;
a8c33204
PB		 1987
1988 target_to_host_sigset(&host_set, &uc->tuc_sigmask);
1c275925 1989 do_sigprocmask(SIG_SETMASK, &host_set, NULL);
a8c33204
PB		 1990
1991 if (restore_sigcontext(env, &uc->tuc_mcontext))
1992 return 1;
1993
5f9099d9
PM		 1994 /* Restore coprocessor signal frame */
1995 regspace = uc->tuc_regspace;
1996 if (arm_feature(env, ARM_FEATURE_VFP)) {
1997 regspace = restore_sigframe_v2_vfp(env, regspace);
1998 if (!regspace) {
1999 return 1;
2000 }
2001 }
a59d69da
PM		 2002 if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
2003 regspace = restore_sigframe_v2_iwmmxt(env, regspace);
2004 if (!regspace) {
2005 return 1;
2006 }
2007 }
5f9099d9 2008
a8c33204
PB		 2009 if (do_sigaltstack(frame_addr + offsetof(struct target_ucontext_v2, tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT)
2010 return 1;
2011
2012#if 0
2013 /* Send SIGTRAP if we're single-stepping */
2014 if (ptrace_cancel_bpt(current))
2015 send_sig(SIGTRAP, current, 1);
2016#endif
2017
2018 return 0;
2019}
2020
05390248 2021static long do_sigreturn_v2(CPUARMState *env)
a8c33204
PB		 2022{
2023 abi_ulong frame_addr;
978fae9f 2024 struct sigframe_v2 *frame = NULL;
a8c33204
PB		 2025
2026 /*
2027 * Since we stacked the signal on a 64-bit boundary,
2028 * then 'sp' should be word aligned here. If it's
2029 * not, then the user is trying to mess with us.
2030 */
a8c33204 2031 frame_addr = env->regs[13];
978fae9f
PM		 2032 if (frame_addr & 7) {
2033 goto badframe;
2034 }
2035
a8c33204
PB		 2036 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
2037 goto badframe;
2038
2039 if (do_sigframe_return_v2(env, frame_addr, &frame->uc))
2040 goto badframe;
2041
2042 unlock_user_struct(frame, frame_addr, 0);
2043 return env->regs[0];
2044
2045badframe:
2046 unlock_user_struct(frame, frame_addr, 0);
66393fb9 2047 force_sig(TARGET_SIGSEGV /* , current */);
a8c33204
PB		 2048 return 0;
2049}
2050
05390248 2051long do_sigreturn(CPUARMState *env)
a8c33204
PB		 2052{
2053 if (get_osversion() >= 0x020612) {
2054 return do_sigreturn_v2(env);
2055 } else {
2056 return do_sigreturn_v1(env);
2057 }
2058}
2059
05390248 2060static long do_rt_sigreturn_v1(CPUARMState *env)
43fff238 2061{
f8b0aa25 2062 abi_ulong frame_addr;
978fae9f 2063 struct rt_sigframe_v1 *frame = NULL;
a745ec6d
PB		 2064 sigset_t host_set;
2065
2066 /*
2067 * Since we stacked the signal on a 64-bit boundary,
2068 * then 'sp' should be word aligned here. If it's
2069 * not, then the user is trying to mess with us.
2070 */
a745ec6d 2071 frame_addr = env->regs[13];
978fae9f
PM		 2072 if (frame_addr & 7) {
2073 goto badframe;
2074 }
2075
a745ec6d
PB		 2076 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
2077 goto badframe;
2078
2079 target_to_host_sigset(&host_set, &frame->uc.tuc_sigmask);
1c275925 2080 do_sigprocmask(SIG_SETMASK, &host_set, NULL);
a745ec6d
PB		 2081
2082 if (restore_sigcontext(env, &frame->uc.tuc_mcontext))
2083 goto badframe;
2084
2085 if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe_v1, uc.tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT)
2086 goto badframe;
2087
2088#if 0
2089 /* Send SIGTRAP if we're single-stepping */
2090 if (ptrace_cancel_bpt(current))
2091 send_sig(SIGTRAP, current, 1);
2092#endif
2093 unlock_user_struct(frame, frame_addr, 0);
2094 return env->regs[0];
2095
2096badframe:
2097 unlock_user_struct(frame, frame_addr, 0);
66393fb9 2098 force_sig(TARGET_SIGSEGV /* , current */);
a745ec6d
PB		 2099 return 0;
2100}
2101
05390248 2102static long do_rt_sigreturn_v2(CPUARMState *env)
a745ec6d
PB		 2103{
2104 abi_ulong frame_addr;
978fae9f 2105 struct rt_sigframe_v2 *frame = NULL;
43fff238
FB		 2106
2107 /*
2108 * Since we stacked the signal on a 64-bit boundary,
2109 * then 'sp' should be word aligned here. If it's
2110 * not, then the user is trying to mess with us.
2111 */
f8b0aa25 2112 frame_addr = env->regs[13];
978fae9f
PM		 2113 if (frame_addr & 7) {
2114 goto badframe;
2115 }
2116
f8b0aa25
FB		 2117 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
2118 goto badframe;
43fff238 2119
a8c33204
PB		 2120 if (do_sigframe_return_v2(env, frame_addr, &frame->uc))
2121 goto badframe;
a04e134a 2122
f8b0aa25 2123 unlock_user_struct(frame, frame_addr, 0);
43fff238
FB		 2124 return env->regs[0];
2125
2126badframe:
f8b0aa25 2127 unlock_user_struct(frame, frame_addr, 0);
66393fb9 2128 force_sig(TARGET_SIGSEGV /* , current */);
43fff238
FB		 2129 return 0;
2130}
2131
05390248 2132long do_rt_sigreturn(CPUARMState *env)
a745ec6d
PB		 2133{
2134 if (get_osversion() >= 0x020612) {
2135 return do_rt_sigreturn_v2(env);
2136 } else {
2137 return do_rt_sigreturn_v1(env);
2138 }
2139}
2140
6d5e216d 2141#elif defined(TARGET_SPARC)
80a9d035 2142
6d5e216d
FB		 2143#define __SUNOS_MAXWIN 31
2144
2145/* This is what SunOS does, so shall I. */
2146struct target_sigcontext {
992f48a0 2147 abi_ulong sigc_onstack; /* state to restore */
6d5e216d 2148
992f48a0
BS		 2149 abi_ulong sigc_mask; /* sigmask to restore */
2150 abi_ulong sigc_sp; /* stack pointer */
2151 abi_ulong sigc_pc; /* program counter */
2152 abi_ulong sigc_npc; /* next program counter */
2153 abi_ulong sigc_psr; /* for condition codes etc */
2154 abi_ulong sigc_g1; /* User uses these two registers */
2155 abi_ulong sigc_o0; /* within the trampoline code. */
6d5e216d
FB		 2156
2157 /* Now comes information regarding the users window set
2158 * at the time of the signal.
2159 */
992f48a0 2160 abi_ulong sigc_oswins; /* outstanding windows */
6d5e216d
FB		 2161
2162 /* stack ptrs for each regwin buf */
2163 char *sigc_spbuf[__SUNOS_MAXWIN];
2164
2165 /* Windows to restore after signal */
2166 struct {
992f48a0
BS		 2167 abi_ulong locals[8];
2168 abi_ulong ins[8];
6d5e216d
FB		 2169 } sigc_wbuf[__SUNOS_MAXWIN];
2170};
2171/* A Sparc stack frame */
2172struct sparc_stackf {
992f48a0 2173 abi_ulong locals[8];
e321c34a
PM		 2174 abi_ulong ins[8];
2175 /* It's simpler to treat fp and callers_pc as elements of ins[]
2176 * since we never need to access them ourselves.
2177 */
6d5e216d 2178 char *structptr;
992f48a0
BS		 2179 abi_ulong xargs[6];
2180 abi_ulong xxargs[1];
6d5e216d
FB		 2181};
2182
2183typedef struct {
2184 struct {
992f48a0
BS		 2185 abi_ulong psr;
2186 abi_ulong pc;
2187 abi_ulong npc;
2188 abi_ulong y;
2189 abi_ulong u_regs[16]; /* globals and ins */
6d5e216d
FB		 2190 } si_regs;
2191 int si_mask;
2192} __siginfo_t;
2193
2194typedef struct {
8954bae3 2195 abi_ulong si_float_regs[32];
6d5e216d
FB		 2196 unsigned long si_fsr;
2197 unsigned long si_fpqdepth;
2198 struct {
2199 unsigned long *insn_addr;
2200 unsigned long insn;
2201 } si_fpqueue [16];
c227f099 2202} qemu_siginfo_fpu_t;
6d5e216d
FB		 2203
2204
2205struct target_signal_frame {
2206 struct sparc_stackf ss;
2207 __siginfo_t info;
f8b0aa25 2208 abi_ulong fpu_save;
992f48a0
BS		 2209 abi_ulong insns[2] __attribute__ ((aligned (8)));
2210 abi_ulong extramask[TARGET_NSIG_WORDS - 1];
2211 abi_ulong extra_size; /* Should be 0 */
c227f099 2212 qemu_siginfo_fpu_t fpu_state;
6d5e216d
FB		 2213};
2214struct target_rt_signal_frame {
2215 struct sparc_stackf ss;
2216 siginfo_t info;
992f48a0 2217 abi_ulong regs[20];
6d5e216d 2218 sigset_t mask;
f8b0aa25 2219 abi_ulong fpu_save;
6d5e216d
FB		 2220 unsigned int insns[2];
2221 stack_t stack;
2222 unsigned int extra_size; /* Should be 0 */
c227f099 2223 qemu_siginfo_fpu_t fpu_state;
6d5e216d
FB		 2224};
2225
e80cfcfc
FB		 2226#define UREG_O0 16
2227#define UREG_O6 22
2228#define UREG_I0 0
2229#define UREG_I1 1
2230#define UREG_I2 2
5bfb56b2
BS		 2231#define UREG_I3 3
2232#define UREG_I4 4
2233#define UREG_I5 5
e80cfcfc
FB		 2234#define UREG_I6 6
2235#define UREG_I7 7
2236#define UREG_L0 8
6d5e216d
FB		 2237#define UREG_FP UREG_I6
2238#define UREG_SP UREG_O6
2239
624f7979 2240static inline abi_ulong get_sigframe(struct target_sigaction *sa,
05390248
AF		 2241 CPUSPARCState *env,
2242 unsigned long framesize)
6d5e216d 2243{
459a4017 2244 abi_ulong sp;
6d5e216d
FB		 2245
2246 sp = env->regwptr[UREG_FP];
6d5e216d
FB		 2247
2248 /* This is the X/Open sanctioned signal stack switching. */
624f7979 2249 if (sa->sa_flags & TARGET_SA_ONSTACK) {
a04e134a
TS		 2250 if (!on_sig_stack(sp)
2251 && !((target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size) & 7))
2252 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
6d5e216d 2253 }
459a4017 2254 return sp - framesize;
6d5e216d
FB		 2255}
2256
2257static int
05390248 2258setup___siginfo(__siginfo_t *si, CPUSPARCState *env, abi_ulong mask)
6d5e216d
FB		 2259{
2260 int err = 0, i;
2261
1d8b512b
RV		 2262 __put_user(env->psr, &si->si_regs.psr);
2263 __put_user(env->pc, &si->si_regs.pc);
2264 __put_user(env->npc, &si->si_regs.npc);
2265 __put_user(env->y, &si->si_regs.y);
a315a145 2266 for (i=0; i < 8; i++) {
1d8b512b 2267 __put_user(env->gregs[i], &si->si_regs.u_regs[i]);
6d5e216d 2268 }
a315a145 2269 for (i=0; i < 8; i++) {
1d8b512b 2270 __put_user(env->regwptr[UREG_I0 + i], &si->si_regs.u_regs[i+8]);
6d5e216d 2271 }
1d8b512b 2272 __put_user(mask, &si->si_mask);
6d5e216d
FB		 2273 return err;
2274}
e80cfcfc 2275
80a9d035 2276#if 0
6d5e216d
FB		 2277static int
2278setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
05390248 2279 CPUSPARCState *env, unsigned long mask)
6d5e216d
FB		 2280{
2281 int err = 0;
2282
1d8b512b
RV		 2283 __put_user(mask, &sc->sigc_mask);
2284 __put_user(env->regwptr[UREG_SP], &sc->sigc_sp);
2285 __put_user(env->pc, &sc->sigc_pc);
2286 __put_user(env->npc, &sc->sigc_npc);
2287 __put_user(env->psr, &sc->sigc_psr);
2288 __put_user(env->gregs[1], &sc->sigc_g1);
2289 __put_user(env->regwptr[UREG_O0], &sc->sigc_o0);
6d5e216d
FB		 2290
2291 return err;
2292}
80a9d035 2293#endif
6d5e216d
FB		 2294#define NF_ALIGNEDSZ (((sizeof(struct target_signal_frame) + 7) & (~7)))
2295
624f7979 2296static void setup_frame(int sig, struct target_sigaction *ka,
05390248 2297 target_sigset_t *set, CPUSPARCState *env)
6d5e216d 2298{
459a4017 2299 abi_ulong sf_addr;
6d5e216d
FB		 2300 struct target_signal_frame *sf;
2301 int sigframe_size, err, i;
2302
2303 /* 1. Make sure everything is clean */
2304 //synchronize_user_stack();
2305
2306 sigframe_size = NF_ALIGNEDSZ;
459a4017 2307 sf_addr = get_sigframe(ka, env, sigframe_size);
6d5e216d 2308
459a4017
FB		 2309 sf = lock_user(VERIFY_WRITE, sf_addr,
2310 sizeof(struct target_signal_frame), 0);
2311 if (!sf)
2312 goto sigsegv;
2313
e80cfcfc 2314 //fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
6d5e216d
FB		 2315#if 0
2316 if (invalid_frame_pointer(sf, sigframe_size))
2317 goto sigill_and_return;
2318#endif
2319 /* 2. Save the current process state */
2320 err = setup___siginfo(&sf->info, env, set->sig[0]);
1d8b512b 2321 __put_user(0, &sf->extra_size);
6d5e216d 2322
1d8b512b
RV		 2323 //save_fpu_state(regs, &sf->fpu_state);
2324 //__put_user(&sf->fpu_state, &sf->fpu_save);
6d5e216d 2325
1d8b512b 2326 __put_user(set->sig[0], &sf->info.si_mask);
6d5e216d 2327 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
1d8b512b 2328 __put_user(set->sig[i + 1], &sf->extramask[i]);
6d5e216d
FB		 2329 }
2330
a315a145 2331 for (i = 0; i < 8; i++) {
1d8b512b 2332 __put_user(env->regwptr[i + UREG_L0], &sf->ss.locals[i]);
6d5e216d 2333 }
a315a145 2334 for (i = 0; i < 8; i++) {
1d8b512b 2335 __put_user(env->regwptr[i + UREG_I0], &sf->ss.ins[i]);
6d5e216d 2336 }
6d5e216d
FB		 2337 if (err)
2338 goto sigsegv;
2339
2340 /* 3. signal handler back-trampoline and parameters */
459a4017 2341 env->regwptr[UREG_FP] = sf_addr;
6d5e216d 2342 env->regwptr[UREG_I0] = sig;
459a4017
FB		 2343 env->regwptr[UREG_I1] = sf_addr +
2344 offsetof(struct target_signal_frame, info);
2345 env->regwptr[UREG_I2] = sf_addr +
2346 offsetof(struct target_signal_frame, info);
6d5e216d
FB		 2347
2348 /* 4. signal handler */
624f7979 2349 env->pc = ka->_sa_handler;
6d5e216d
FB		 2350 env->npc = (env->pc + 4);
2351 /* 5. return to kernel instructions */
624f7979
PB		 2352 if (ka->sa_restorer)
2353 env->regwptr[UREG_I7] = ka->sa_restorer;
6d5e216d 2354 else {
775b58d8 2355 uint32_t val32;
459a4017
FB		 2356
2357 env->regwptr[UREG_I7] = sf_addr +
2358 offsetof(struct target_signal_frame, insns) - 2 * 4;
6d5e216d
FB		 2359
2360 /* mov __NR_sigreturn, %g1 */
775b58d8 2361 val32 = 0x821020d8;
1d8b512b 2362 __put_user(val32, &sf->insns[0]);
6d5e216d
FB		 2363
2364 /* t 0x10 */
775b58d8 2365 val32 = 0x91d02010;
1d8b512b 2366 __put_user(val32, &sf->insns[1]);
6d5e216d
FB		 2367 if (err)
2368 goto sigsegv;
2369
2370 /* Flush instruction space. */
2371 //flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
80a9d035 2372 // tb_flush(env);
6d5e216d 2373 }
459a4017 2374 unlock_user(sf, sf_addr, sizeof(struct target_signal_frame));
6d5e216d 2375 return;
459a4017
FB		 2376#if 0
2377sigill_and_return:
6d5e216d 2378 force_sig(TARGET_SIGILL);
459a4017 2379#endif
6d5e216d 2380sigsegv:
e80cfcfc 2381 //fprintf(stderr, "force_sig\n");
459a4017 2382 unlock_user(sf, sf_addr, sizeof(struct target_signal_frame));
6d5e216d
FB		 2383 force_sig(TARGET_SIGSEGV);
2384}
2385static inline int
05390248 2386restore_fpu_state(CPUSPARCState *env, qemu_siginfo_fpu_t *fpu)
6d5e216d
FB		 2387{
2388 int err;
2389#if 0
2390#ifdef CONFIG_SMP
2391 if (current->flags & PF_USEDFPU)
2392 regs->psr &= ~PSR_EF;
2393#else
2394 if (current == last_task_used_math) {
2395 last_task_used_math = 0;
2396 regs->psr &= ~PSR_EF;
2397 }
2398#endif
2399 current->used_math = 1;
2400 current->flags &= ~PF_USEDFPU;
2401#endif
2402#if 0
2403 if (verify_area (VERIFY_READ, fpu, sizeof(*fpu)))
2404 return -EFAULT;
2405#endif
2406
fafffaef 2407 /* XXX: incorrect */
8954bae3
BS		 2408 err = copy_from_user(&env->fpr[0], fpu->si_float_regs[0],
2409 (sizeof(abi_ulong) * 32));
6d5e216d
FB		 2410 err |= __get_user(env->fsr, &fpu->si_fsr);
2411#if 0
2412 err |= __get_user(current->thread.fpqdepth, &fpu->si_fpqdepth);
2413 if (current->thread.fpqdepth != 0)
2414 err |= __copy_from_user(&current->thread.fpqueue[0],
2415 &fpu->si_fpqueue[0],
2416 ((sizeof(unsigned long) +
2417 (sizeof(unsigned long *)))*16));
2418#endif
2419 return err;
2420}
2421
2422
624f7979 2423static void setup_rt_frame(int sig, struct target_sigaction *ka,
c227f099 2424 target_siginfo_t *info,
05390248 2425 target_sigset_t *set, CPUSPARCState *env)
6d5e216d
FB		 2426{
2427 fprintf(stderr, "setup_rt_frame: not implemented\n");
2428}
2429
05390248 2430long do_sigreturn(CPUSPARCState *env)
6d5e216d 2431{
f8b0aa25 2432 abi_ulong sf_addr;
6d5e216d 2433 struct target_signal_frame *sf;
e80cfcfc 2434 uint32_t up_psr, pc, npc;
c227f099 2435 target_sigset_t set;
e80cfcfc 2436 sigset_t host_set;
1d8b512b 2437 int err=0, i;
6d5e216d 2438
f8b0aa25
FB		 2439 sf_addr = env->regwptr[UREG_FP];
2440 if (!lock_user_struct(VERIFY_READ, sf, sf_addr, 1))
2441 goto segv_and_exit;
80a9d035 2442#if 0
e80cfcfc
FB		 2443 fprintf(stderr, "sigreturn\n");
2444 fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
80a9d035 2445#endif
e80cfcfc 2446 //cpu_dump_state(env, stderr, fprintf, 0);
6d5e216d
FB		 2447
2448 /* 1. Make sure we are not getting garbage from the user */
6d5e216d 2449
f8b0aa25 2450 if (sf_addr & 3)
6d5e216d
FB		 2451 goto segv_and_exit;
2452
1d8b512b
RV		 2453 __get_user(pc, &sf->info.si_regs.pc);
2454 __get_user(npc, &sf->info.si_regs.npc);
6d5e216d 2455
6d5e216d
FB		 2456 if ((pc | npc) & 3)
2457 goto segv_and_exit;
2458
2459 /* 2. Restore the state */
1d8b512b 2460 __get_user(up_psr, &sf->info.si_regs.psr);
e80cfcfc 2461
6d5e216d 2462 /* User can only change condition codes and FPU enabling in %psr. */
a315a145
FB		 2463 env->psr = (up_psr & (PSR_ICC /* | PSR_EF */))
2464 | (env->psr & ~(PSR_ICC /* | PSR_EF */));
2465
2466 env->pc = pc;
2467 env->npc = npc;
1d8b512b 2468 __get_user(env->y, &sf->info.si_regs.y);
a315a145 2469 for (i=0; i < 8; i++) {
1d8b512b 2470 __get_user(env->gregs[i], &sf->info.si_regs.u_regs[i]);
e80cfcfc 2471 }
a315a145 2472 for (i=0; i < 8; i++) {
1d8b512b 2473 __get_user(env->regwptr[i + UREG_I0], &sf->info.si_regs.u_regs[i+8]);
e80cfcfc 2474 }
6d5e216d 2475
2aec3a27
PM		 2476 /* FIXME: implement FPU save/restore:
2477 * __get_user(fpu_save, &sf->fpu_save);
2478 * if (fpu_save)
2479 * err |= restore_fpu_state(env, fpu_save);
2480 */
6d5e216d
FB		 2481
2482 /* This is pretty much atomic, no amount locking would prevent
2483 * the races which exist anyways.
2484 */
1d8b512b 2485 __get_user(set.sig[0], &sf->info.si_mask);
e80cfcfc 2486 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1d8b512b 2487 __get_user(set.sig[i], &sf->extramask[i - 1]);
e80cfcfc
FB		 2488 }
2489
2490 target_to_host_sigset_internal(&host_set, &set);
1c275925 2491 do_sigprocmask(SIG_SETMASK, &host_set, NULL);
6d5e216d
FB		 2492
2493 if (err)
2494 goto segv_and_exit;
f8b0aa25 2495 unlock_user_struct(sf, sf_addr, 0);
6d5e216d
FB		 2496 return env->regwptr[0];
2497
2498segv_and_exit:
f8b0aa25 2499 unlock_user_struct(sf, sf_addr, 0);
6d5e216d
FB		 2500 force_sig(TARGET_SIGSEGV);
2501}
2502
05390248 2503long do_rt_sigreturn(CPUSPARCState *env)
6d5e216d
FB		 2504{
2505 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
f8b0aa25 2506 return -TARGET_ENOSYS;
6d5e216d
FB		 2507}
2508
459a4017 2509#if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
5bfb56b2
BS		 2510#define MC_TSTATE 0
2511#define MC_PC 1
2512#define MC_NPC 2
2513#define MC_Y 3
2514#define MC_G1 4
2515#define MC_G2 5
2516#define MC_G3 6
2517#define MC_G4 7
2518#define MC_G5 8
2519#define MC_G6 9
2520#define MC_G7 10
2521#define MC_O0 11
2522#define MC_O1 12
2523#define MC_O2 13
2524#define MC_O3 14
2525#define MC_O4 15
2526#define MC_O5 16
2527#define MC_O6 17
2528#define MC_O7 18
2529#define MC_NGREG 19
2530
c227f099
AL		 2531typedef abi_ulong target_mc_greg_t;
2532typedef target_mc_greg_t target_mc_gregset_t[MC_NGREG];
5bfb56b2
BS		 2533
2534struct target_mc_fq {
992f48a0 2535 abi_ulong *mcfq_addr;
5bfb56b2
BS		 2536 uint32_t mcfq_insn;
2537};
2538
2539struct target_mc_fpu {
2540 union {
2541 uint32_t sregs[32];
2542 uint64_t dregs[32];
2543 //uint128_t qregs[16];
2544 } mcfpu_fregs;
992f48a0
BS		 2545 abi_ulong mcfpu_fsr;
2546 abi_ulong mcfpu_fprs;
2547 abi_ulong mcfpu_gsr;
5bfb56b2
BS		 2548 struct target_mc_fq *mcfpu_fq;
2549 unsigned char mcfpu_qcnt;
2550 unsigned char mcfpu_qentsz;
2551 unsigned char mcfpu_enab;
2552};
c227f099 2553typedef struct target_mc_fpu target_mc_fpu_t;
5bfb56b2
BS		 2554
2555typedef struct {
c227f099
AL		 2556 target_mc_gregset_t mc_gregs;
2557 target_mc_greg_t mc_fp;
2558 target_mc_greg_t mc_i7;
2559 target_mc_fpu_t mc_fpregs;
2560} target_mcontext_t;
5bfb56b2
BS		 2561
2562struct target_ucontext {
60e99246
AJ		 2563 struct target_ucontext *tuc_link;
2564 abi_ulong tuc_flags;
2565 target_sigset_t tuc_sigmask;
2566 target_mcontext_t tuc_mcontext;
5bfb56b2
BS		 2567};
2568
2569/* A V9 register window */
2570struct target_reg_window {
992f48a0
BS		 2571 abi_ulong locals[8];
2572 abi_ulong ins[8];
5bfb56b2
BS		 2573};
2574
2575#define TARGET_STACK_BIAS 2047
2576
2577/* {set, get}context() needed for 64-bit SparcLinux userland. */
2578void sparc64_set_context(CPUSPARCState *env)
2579{
459a4017
FB		 2580 abi_ulong ucp_addr;
2581 struct target_ucontext *ucp;
c227f099 2582 target_mc_gregset_t *grp;
992f48a0 2583 abi_ulong pc, npc, tstate;
459a4017 2584 abi_ulong fp, i7, w_addr;
1d8b512b 2585 int err = 0;
5bfb56b2 2586 unsigned int i;
5bfb56b2 2587
459a4017
FB		 2588 ucp_addr = env->regwptr[UREG_I0];
2589 if (!lock_user_struct(VERIFY_READ, ucp, ucp_addr, 1))
2590 goto do_sigsegv;
60e99246 2591 grp = &ucp->tuc_mcontext.mc_gregs;
1d8b512b
RV		 2592 __get_user(pc, &((*grp)[MC_PC]));
2593 __get_user(npc, &((*grp)[MC_NPC]));
5bfb56b2
BS		 2594 if (err || ((pc | npc) & 3))
2595 goto do_sigsegv;
2596 if (env->regwptr[UREG_I1]) {
c227f099 2597 target_sigset_t target_set;
5bfb56b2
BS		 2598 sigset_t set;
2599
2600 if (TARGET_NSIG_WORDS == 1) {
60e99246 2601 if (__get_user(target_set.sig[0], &ucp->tuc_sigmask.sig[0]))
5bfb56b2
BS		 2602 goto do_sigsegv;
2603 } else {
459a4017 2604 abi_ulong *src, *dst;
60e99246 2605 src = ucp->tuc_sigmask.sig;
459a4017 2606 dst = target_set.sig;
0d9e61c2 2607 for (i = 0; i < TARGET_NSIG_WORDS; i++, dst++, src++) {
1d8b512b 2608 __get_user(*dst, src);
0d9e61c2 2609 }
5bfb56b2
BS		 2610 if (err)
2611 goto do_sigsegv;
2612 }
2613 target_to_host_sigset_internal(&set, &target_set);
1c275925 2614 do_sigprocmask(SIG_SETMASK, &set, NULL);
5bfb56b2
BS		 2615 }
2616 env->pc = pc;
2617 env->npc = npc;
1d8b512b
RV		 2618 __get_user(env->y, &((*grp)[MC_Y]));
2619 __get_user(tstate, &((*grp)[MC_TSTATE]));
5bfb56b2 2620 env->asi = (tstate >> 24) & 0xff;
5a834bb4
BS		 2621 cpu_put_ccr(env, tstate >> 32);
2622 cpu_put_cwp64(env, tstate & 0x1f);
1d8b512b
RV		 2623 __get_user(env->gregs[1], (&(*grp)[MC_G1]));
2624 __get_user(env->gregs[2], (&(*grp)[MC_G2]));
2625 __get_user(env->gregs[3], (&(*grp)[MC_G3]));
2626 __get_user(env->gregs[4], (&(*grp)[MC_G4]));
2627 __get_user(env->gregs[5], (&(*grp)[MC_G5]));
2628 __get_user(env->gregs[6], (&(*grp)[MC_G6]));
2629 __get_user(env->gregs[7], (&(*grp)[MC_G7]));
2630 __get_user(env->regwptr[UREG_I0], (&(*grp)[MC_O0]));
2631 __get_user(env->regwptr[UREG_I1], (&(*grp)[MC_O1]));
2632 __get_user(env->regwptr[UREG_I2], (&(*grp)[MC_O2]));
2633 __get_user(env->regwptr[UREG_I3], (&(*grp)[MC_O3]));
2634 __get_user(env->regwptr[UREG_I4], (&(*grp)[MC_O4]));
2635 __get_user(env->regwptr[UREG_I5], (&(*grp)[MC_O5]));
2636 __get_user(env->regwptr[UREG_I6], (&(*grp)[MC_O6]));
2637 __get_user(env->regwptr[UREG_I7], (&(*grp)[MC_O7]));
2638
2639 __get_user(fp, &(ucp->tuc_mcontext.mc_fp));
2640 __get_user(i7, &(ucp->tuc_mcontext.mc_i7));
579a97f7 2641
459a4017
FB		 2642 w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
2643 if (put_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]),
2644 abi_ulong) != 0)
2645 goto do_sigsegv;
2646 if (put_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]),
2647 abi_ulong) != 0)
2648 goto do_sigsegv;
c7b016ba
PM		 2649 /* FIXME this does not match how the kernel handles the FPU in
2650 * its sparc64_set_context implementation. In particular the FPU
2651 * is only restored if fenab is non-zero in:
2652 * __get_user(fenab, &(ucp->tuc_mcontext.mc_fpregs.mcfpu_enab));
2653 */
60e99246 2654 err |= __get_user(env->fprs, &(ucp->tuc_mcontext.mc_fpregs.mcfpu_fprs));
459a4017 2655 {
30038fd8
RH		 2656 uint32_t *src = ucp->tuc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2657 for (i = 0; i < 64; i++, src++) {
2658 if (i & 1) {
1d8b512b 2659 __get_user(env->fpr[i/2].l.lower, src);
30038fd8 2660 } else {
1d8b512b 2661 __get_user(env->fpr[i/2].l.upper, src);
30038fd8
RH		 2662 }
2663 }
459a4017 2664 }
1d8b512b
RV		 2665 __get_user(env->fsr,
2666 &(ucp->tuc_mcontext.mc_fpregs.mcfpu_fsr));
2667 __get_user(env->gsr,
2668 &(ucp->tuc_mcontext.mc_fpregs.mcfpu_gsr));
5bfb56b2
BS		 2669 if (err)
2670 goto do_sigsegv;
459a4017 2671 unlock_user_struct(ucp, ucp_addr, 0);
5bfb56b2
BS		 2672 return;
2673 do_sigsegv:
459a4017 2674 unlock_user_struct(ucp, ucp_addr, 0);
66393fb9 2675 force_sig(TARGET_SIGSEGV);
5bfb56b2
BS		 2676}
2677
2678void sparc64_get_context(CPUSPARCState *env)
2679{
459a4017
FB		 2680 abi_ulong ucp_addr;
2681 struct target_ucontext *ucp;
c227f099
AL		 2682 target_mc_gregset_t *grp;
2683 target_mcontext_t *mcp;
459a4017 2684 abi_ulong fp, i7, w_addr;
5bfb56b2
BS		 2685 int err;
2686 unsigned int i;
c227f099 2687 target_sigset_t target_set;
5bfb56b2
BS		 2688 sigset_t set;
2689
459a4017
FB		 2690 ucp_addr = env->regwptr[UREG_I0];
2691 if (!lock_user_struct(VERIFY_WRITE, ucp, ucp_addr, 0))
2692 goto do_sigsegv;
2693
60e99246 2694 mcp = &ucp->tuc_mcontext;
5bfb56b2
BS		 2695 grp = &mcp->mc_gregs;
2696
2697 /* Skip over the trap instruction, first. */
2698 env->pc = env->npc;
2699 env->npc += 4;
2700
2701 err = 0;
2702
1c275925 2703 do_sigprocmask(0, NULL, &set);
5bfb56b2 2704 host_to_target_sigset_internal(&target_set, &set);
459a4017 2705 if (TARGET_NSIG_WORDS == 1) {
1d8b512b
RV		 2706 __put_user(target_set.sig[0],
2707 (abi_ulong *)&ucp->tuc_sigmask);
459a4017
FB		 2708 } else {
2709 abi_ulong *src, *dst;
2710 src = target_set.sig;
60e99246 2711 dst = ucp->tuc_sigmask.sig;
0d9e61c2 2712 for (i = 0; i < TARGET_NSIG_WORDS; i++, dst++, src++) {
1d8b512b 2713 __put_user(*src, dst);
0d9e61c2 2714 }
5bfb56b2
BS		 2715 if (err)
2716 goto do_sigsegv;
2717 }
2718
459a4017 2719 /* XXX: tstate must be saved properly */
1d8b512b
RV		 2720 // __put_user(env->tstate, &((*grp)[MC_TSTATE]));
2721 __put_user(env->pc, &((*grp)[MC_PC]));
2722 __put_user(env->npc, &((*grp)[MC_NPC]));
2723 __put_user(env->y, &((*grp)[MC_Y]));
2724 __put_user(env->gregs[1], &((*grp)[MC_G1]));
2725 __put_user(env->gregs[2], &((*grp)[MC_G2]));
2726 __put_user(env->gregs[3], &((*grp)[MC_G3]));
2727 __put_user(env->gregs[4], &((*grp)[MC_G4]));
2728 __put_user(env->gregs[5], &((*grp)[MC_G5]));
2729 __put_user(env->gregs[6], &((*grp)[MC_G6]));
2730 __put_user(env->gregs[7], &((*grp)[MC_G7]));
2731 __put_user(env->regwptr[UREG_I0], &((*grp)[MC_O0]));
2732 __put_user(env->regwptr[UREG_I1], &((*grp)[MC_O1]));
2733 __put_user(env->regwptr[UREG_I2], &((*grp)[MC_O2]));
2734 __put_user(env->regwptr[UREG_I3], &((*grp)[MC_O3]));
2735 __put_user(env->regwptr[UREG_I4], &((*grp)[MC_O4]));
2736 __put_user(env->regwptr[UREG_I5], &((*grp)[MC_O5]));
2737 __put_user(env->regwptr[UREG_I6], &((*grp)[MC_O6]));
2738 __put_user(env->regwptr[UREG_I7], &((*grp)[MC_O7]));
579a97f7 2739
459a4017
FB		 2740 w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
2741 fp = i7 = 0;
2742 if (get_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]),
2743 abi_ulong) != 0)
2744 goto do_sigsegv;
2745 if (get_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]),
2746 abi_ulong) != 0)
2747 goto do_sigsegv;
1d8b512b
RV		 2748 __put_user(fp, &(mcp->mc_fp));
2749 __put_user(i7, &(mcp->mc_i7));
5bfb56b2 2750
459a4017 2751 {
30038fd8
RH		 2752 uint32_t *dst = ucp->tuc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2753 for (i = 0; i < 64; i++, dst++) {
2754 if (i & 1) {
1d8b512b 2755 __put_user(env->fpr[i/2].l.lower, dst);
30038fd8 2756 } else {
1d8b512b 2757 __put_user(env->fpr[i/2].l.upper, dst);
30038fd8
RH		 2758 }
2759 }
459a4017 2760 }
1d8b512b
RV		 2761 __put_user(env->fsr, &(mcp->mc_fpregs.mcfpu_fsr));
2762 __put_user(env->gsr, &(mcp->mc_fpregs.mcfpu_gsr));
2763 __put_user(env->fprs, &(mcp->mc_fpregs.mcfpu_fprs));
5bfb56b2
BS		 2764
2765 if (err)
2766 goto do_sigsegv;
459a4017 2767 unlock_user_struct(ucp, ucp_addr, 1);
5bfb56b2
BS		 2768 return;
2769 do_sigsegv:
459a4017 2770 unlock_user_struct(ucp, ucp_addr, 1);
66393fb9 2771 force_sig(TARGET_SIGSEGV);
5bfb56b2
BS		 2772}
2773#endif
ff970904 2774#elif defined(TARGET_MIPS) || defined(TARGET_MIPS64)
106ec879 2775
ff970904 2776# if defined(TARGET_ABI_MIPSO32)
106ec879
FB		 2777struct target_sigcontext {
2778 uint32_t sc_regmask; /* Unused */
2779 uint32_t sc_status;
2780 uint64_t sc_pc;
2781 uint64_t sc_regs[32];
2782 uint64_t sc_fpregs[32];
2783 uint32_t sc_ownedfp; /* Unused */
2784 uint32_t sc_fpc_csr;
2785 uint32_t sc_fpc_eir; /* Unused */
2786 uint32_t sc_used_math;
2787 uint32_t sc_dsp; /* dsp status, was sc_ssflags */
94c5495d 2788 uint32_t pad0;
106ec879
FB		 2789 uint64_t sc_mdhi;
2790 uint64_t sc_mdlo;
2791 target_ulong sc_hi1; /* Was sc_cause */
2792 target_ulong sc_lo1; /* Was sc_badvaddr */
2793 target_ulong sc_hi2; /* Was sc_sigset[4] */
2794 target_ulong sc_lo2;
2795 target_ulong sc_hi3;
2796 target_ulong sc_lo3;
2797};
ff970904
RH		 2798# else /* N32 || N64 */
2799struct target_sigcontext {
2800 uint64_t sc_regs[32];
2801 uint64_t sc_fpregs[32];
2802 uint64_t sc_mdhi;
2803 uint64_t sc_hi1;
2804 uint64_t sc_hi2;
2805 uint64_t sc_hi3;
2806 uint64_t sc_mdlo;
2807 uint64_t sc_lo1;
2808 uint64_t sc_lo2;
2809 uint64_t sc_lo3;
2810 uint64_t sc_pc;
2811 uint32_t sc_fpc_csr;
2812 uint32_t sc_used_math;
2813 uint32_t sc_dsp;
2814 uint32_t sc_reserved;
2815};
2816# endif /* O32 */
106ec879
FB		 2817
2818struct sigframe {
2819 uint32_t sf_ass[4]; /* argument save space for o32 */
2820 uint32_t sf_code[2]; /* signal trampoline */
2821 struct target_sigcontext sf_sc;
c227f099 2822 target_sigset_t sf_mask;
106ec879
FB		 2823};
2824
0b1bcb00 2825struct target_ucontext {
60e99246
AJ		 2826 target_ulong tuc_flags;
2827 target_ulong tuc_link;
2828 target_stack_t tuc_stack;
94c5495d 2829 target_ulong pad0;
60e99246
AJ		 2830 struct target_sigcontext tuc_mcontext;
2831 target_sigset_t tuc_sigmask;
0b1bcb00
PB		 2832};
2833
2834struct target_rt_sigframe {
2835 uint32_t rs_ass[4]; /* argument save space for o32 */
2836 uint32_t rs_code[2]; /* signal trampoline */
2837 struct target_siginfo rs_info;
2838 struct target_ucontext rs_uc;
2839};
2840
106ec879
FB		 2841/* Install trampoline to jump back from signal handler */
2842static inline int install_sigtramp(unsigned int *tramp, unsigned int syscall)
2843{
084d0497 2844 int err = 0;
106ec879
FB		 2845
2846 /*
084d0497
RH		 2847 * Set up the return code ...
2848 *
2849 * li v0, __NR__foo_sigreturn
2850 * syscall
2851 */
106ec879 2852
1d8b512b
RV		 2853 __put_user(0x24020000 + syscall, tramp + 0);
2854 __put_user(0x0000000c , tramp + 1);
106ec879
FB		 2855 return err;
2856}
2857
2858static inline int
05390248 2859setup_sigcontext(CPUMIPSState *regs, struct target_sigcontext *sc)
106ec879
FB		 2860{
2861 int err = 0;
084d0497 2862 int i;
106ec879 2863
1d8b512b 2864 __put_user(exception_resume_pc(regs), &sc->sc_pc);
1239b472 2865 regs->hflags &= ~MIPS_HFLAG_BMASK;
106ec879 2866
084d0497
RH		 2867 __put_user(0, &sc->sc_regs[0]);
2868 for (i = 1; i < 32; ++i) {
1d8b512b 2869 __put_user(regs->active_tc.gpr[i], &sc->sc_regs[i]);
084d0497 2870 }
106ec879 2871
1d8b512b
RV		 2872 __put_user(regs->active_tc.HI[0], &sc->sc_mdhi);
2873 __put_user(regs->active_tc.LO[0], &sc->sc_mdlo);
106ec879 2874
084d0497
RH		 2875 /* Rather than checking for dsp existence, always copy. The storage
2876 would just be garbage otherwise. */
1d8b512b
RV		 2877 __put_user(regs->active_tc.HI[1], &sc->sc_hi1);
2878 __put_user(regs->active_tc.HI[2], &sc->sc_hi2);
2879 __put_user(regs->active_tc.HI[3], &sc->sc_hi3);
2880 __put_user(regs->active_tc.LO[1], &sc->sc_lo1);
2881 __put_user(regs->active_tc.LO[2], &sc->sc_lo2);
2882 __put_user(regs->active_tc.LO[3], &sc->sc_lo3);
084d0497
RH		 2883 {
2884 uint32_t dsp = cpu_rddsp(0x3ff, regs);
1d8b512b 2885 __put_user(dsp, &sc->sc_dsp);
106ec879 2886 }
106ec879 2887
1d8b512b 2888 __put_user(1, &sc->sc_used_math);
106ec879 2889
084d0497 2890 for (i = 0; i < 32; ++i) {
1d8b512b 2891 __put_user(regs->active_fpu.fpr[i].d, &sc->sc_fpregs[i]);
106ec879 2892 }
106ec879 2893
106ec879
FB		 2894 return err;
2895}
2896
2897static inline int
05390248 2898restore_sigcontext(CPUMIPSState *regs, struct target_sigcontext *sc)
106ec879
FB		 2899{
2900 int err = 0;
084d0497 2901 int i;
106ec879 2902
1d8b512b 2903 __get_user(regs->CP0_EPC, &sc->sc_pc);
106ec879 2904
1d8b512b
RV		 2905 __get_user(regs->active_tc.HI[0], &sc->sc_mdhi);
2906 __get_user(regs->active_tc.LO[0], &sc->sc_mdlo);
106ec879 2907
084d0497 2908 for (i = 1; i < 32; ++i) {
1d8b512b 2909 __get_user(regs->active_tc.gpr[i], &sc->sc_regs[i]);
106ec879 2910 }
106ec879 2911
1d8b512b
RV		 2912 __get_user(regs->active_tc.HI[1], &sc->sc_hi1);
2913 __get_user(regs->active_tc.HI[2], &sc->sc_hi2);
2914 __get_user(regs->active_tc.HI[3], &sc->sc_hi3);
2915 __get_user(regs->active_tc.LO[1], &sc->sc_lo1);
2916 __get_user(regs->active_tc.LO[2], &sc->sc_lo2);
2917 __get_user(regs->active_tc.LO[3], &sc->sc_lo3);
084d0497
RH		 2918 {
2919 uint32_t dsp;
1d8b512b 2920 __get_user(dsp, &sc->sc_dsp);
084d0497
RH		 2921 cpu_wrdsp(dsp, 0x3ff, regs);
2922 }
106ec879 2923
084d0497 2924 for (i = 0; i < 32; ++i) {
1d8b512b 2925 __get_user(regs->active_fpu.fpr[i].d, &sc->sc_fpregs[i]);
106ec879
FB		 2926 }
2927
106ec879
FB		 2928 return err;
2929}
ff970904 2930
106ec879
FB		 2931/*
2932 * Determine which stack to use..
2933 */
579a97f7 2934static inline abi_ulong
05390248 2935get_sigframe(struct target_sigaction *ka, CPUMIPSState *regs, size_t frame_size)
106ec879
FB		 2936{
2937 unsigned long sp;
2938
2939 /* Default to using normal stack */
b5dc7732 2940 sp = regs->active_tc.gpr[29];
106ec879
FB		 2941
2942 /*
93148aa5 2943 * FPU emulator may have its own trampoline active just
106ec879
FB		 2944 * above the user stack, 16-bytes before the next lowest
2945 * 16 byte boundary. Try to avoid trashing it.
2946 */
2947 sp -= 32;
2948
106ec879 2949 /* This is the X/Open sanctioned signal stack switching. */
624f7979 2950 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) {
a04e134a
TS		 2951 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
2952 }
106ec879 2953
579a97f7 2954 return (sp - frame_size) & ~7;
106ec879
FB		 2955}
2956
ea3164aa
KCY		 2957static void mips_set_hflags_isa_mode_from_pc(CPUMIPSState *env)
2958{
2959 if (env->insn_flags & (ASE_MIPS16 | ASE_MICROMIPS)) {
2960 env->hflags &= ~MIPS_HFLAG_M16;
2961 env->hflags |= (env->active_tc.PC & 1) << MIPS_HFLAG_M16_SHIFT;
2962 env->active_tc.PC &= ~(target_ulong) 1;
2963 }
2964}
2965
ff970904 2966# if defined(TARGET_ABI_MIPSO32)
579a97f7 2967/* compare linux/arch/mips/kernel/signal.c:setup_frame() */
624f7979 2968static void setup_frame(int sig, struct target_sigaction * ka,
05390248 2969 target_sigset_t *set, CPUMIPSState *regs)
106ec879
FB		 2970{
2971 struct sigframe *frame;
579a97f7 2972 abi_ulong frame_addr;
106ec879
FB		 2973 int i;
2974
579a97f7
FB		 2975 frame_addr = get_sigframe(ka, regs, sizeof(*frame));
2976 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
106ec879
FB		 2977 goto give_sigsegv;
2978
2979 install_sigtramp(frame->sf_code, TARGET_NR_sigreturn);
2980
2981 if(setup_sigcontext(regs, &frame->sf_sc))
2982 goto give_sigsegv;
2983
2984 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2985 if(__put_user(set->sig[i], &frame->sf_mask.sig[i]))
2986 goto give_sigsegv;
2987 }
2988
2989 /*
2990 * Arguments to signal handler:
2991 *
2992 * a0 = signal number
2993 * a1 = 0 (should be cause)
2994 * a2 = pointer to struct sigcontext
2995 *
2996 * $25 and PC point to the signal handler, $29 points to the
2997 * struct sigframe.
2998 */
b5dc7732
TS		 2999 regs->active_tc.gpr[ 4] = sig;
3000 regs->active_tc.gpr[ 5] = 0;
3001 regs->active_tc.gpr[ 6] = frame_addr + offsetof(struct sigframe, sf_sc);
3002 regs->active_tc.gpr[29] = frame_addr;
3003 regs->active_tc.gpr[31] = frame_addr + offsetof(struct sigframe, sf_code);
106ec879
FB		 3004 /* The original kernel code sets CP0_EPC to the handler
3005 * since it returns to userland using eret
3006 * we cannot do this here, and we must set PC directly */
b5dc7732 3007 regs->active_tc.PC = regs->active_tc.gpr[25] = ka->_sa_handler;
ea3164aa 3008 mips_set_hflags_isa_mode_from_pc(regs);
579a97f7 3009 unlock_user_struct(frame, frame_addr, 1);
106ec879
FB		 3010 return;
3011
3012give_sigsegv:
579a97f7 3013 unlock_user_struct(frame, frame_addr, 1);
106ec879 3014 force_sig(TARGET_SIGSEGV/*, current*/);
106ec879
FB		 3015}
3016
05390248 3017long do_sigreturn(CPUMIPSState *regs)
106ec879 3018{
388bb21a 3019 struct sigframe *frame;
579a97f7 3020 abi_ulong frame_addr;
388bb21a 3021 sigset_t blocked;
c227f099 3022 target_sigset_t target_set;
388bb21a 3023 int i;
106ec879
FB		 3024
3025#if defined(DEBUG_SIGNAL)
388bb21a 3026 fprintf(stderr, "do_sigreturn\n");
106ec879 3027#endif
b5dc7732 3028 frame_addr = regs->active_tc.gpr[29];
579a97f7 3029 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
106ec879
FB		 3030 goto badframe;
3031
388bb21a 3032 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
106ec879
FB		 3033 if(__get_user(target_set.sig[i], &frame->sf_mask.sig[i]))
3034 goto badframe;
388bb21a 3035 }
106ec879 3036
388bb21a 3037 target_to_host_sigset_internal(&blocked, &target_set);
1c275925 3038 do_sigprocmask(SIG_SETMASK, &blocked, NULL);
106ec879 3039
388bb21a 3040 if (restore_sigcontext(regs, &frame->sf_sc))
106ec879
FB		 3041 goto badframe;
3042
3043#if 0
388bb21a
TS		 3044 /*
3045 * Don't let your children do this ...
3046 */
3047 __asm__ __volatile__(
106ec879
FB		 3048 "move\t$29, %0\n\t"
3049 "j\tsyscall_exit"
3050 :/* no outputs */
3051 :"r" (&regs));
388bb21a 3052 /* Unreached */
106ec879 3053#endif
3b46e624 3054
b5dc7732 3055 regs->active_tc.PC = regs->CP0_EPC;
ea3164aa 3056 mips_set_hflags_isa_mode_from_pc(regs);
388bb21a 3057 /* I am not sure this is right, but it seems to work
106ec879
FB		 3058 * maybe a problem with nested signals ? */
3059 regs->CP0_EPC = 0;
0b1bcb00 3060 return -TARGET_QEMU_ESIGRETURN;
106ec879
FB		 3061
3062badframe:
388bb21a
TS		 3063 force_sig(TARGET_SIGSEGV/*, current*/);
3064 return 0;
106ec879 3065}
ff970904 3066# endif /* O32 */
106ec879 3067
624f7979 3068static void setup_rt_frame(int sig, struct target_sigaction *ka,
c227f099 3069 target_siginfo_t *info,
05390248 3070 target_sigset_t *set, CPUMIPSState *env)
106ec879 3071{
0b1bcb00
PB		 3072 struct target_rt_sigframe *frame;
3073 abi_ulong frame_addr;
3074 int i;
3075
3076 frame_addr = get_sigframe(ka, env, sizeof(*frame));
3077 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3078 goto give_sigsegv;
3079
3080 install_sigtramp(frame->rs_code, TARGET_NR_rt_sigreturn);
3081
3082 copy_siginfo_to_user(&frame->rs_info, info);
3083
60e99246
AJ		 3084 __put_user(0, &frame->rs_uc.tuc_flags);
3085 __put_user(0, &frame->rs_uc.tuc_link);
3086 __put_user(target_sigaltstack_used.ss_sp, &frame->rs_uc.tuc_stack.ss_sp);
3087 __put_user(target_sigaltstack_used.ss_size, &frame->rs_uc.tuc_stack.ss_size);
0b1bcb00 3088 __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
60e99246 3089 &frame->rs_uc.tuc_stack.ss_flags);
0b1bcb00 3090
60e99246 3091 setup_sigcontext(env, &frame->rs_uc.tuc_mcontext);
0b1bcb00
PB		 3092
3093 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
60e99246 3094 __put_user(set->sig[i], &frame->rs_uc.tuc_sigmask.sig[i]);
0b1bcb00
PB		 3095 }
3096
3097 /*
3098 * Arguments to signal handler:
3099 *
3100 * a0 = signal number
02d2bd5d 3101 * a1 = pointer to siginfo_t
0b1bcb00
PB		 3102 * a2 = pointer to struct ucontext
3103 *
3104 * $25 and PC point to the signal handler, $29 points to the
3105 * struct sigframe.
3106 */
3107 env->active_tc.gpr[ 4] = sig;
3108 env->active_tc.gpr[ 5] = frame_addr
3109 + offsetof(struct target_rt_sigframe, rs_info);
3110 env->active_tc.gpr[ 6] = frame_addr
3111 + offsetof(struct target_rt_sigframe, rs_uc);
3112 env->active_tc.gpr[29] = frame_addr;
3113 env->active_tc.gpr[31] = frame_addr
3114 + offsetof(struct target_rt_sigframe, rs_code);
3115 /* The original kernel code sets CP0_EPC to the handler
3116 * since it returns to userland using eret
3117 * we cannot do this here, and we must set PC directly */
3118 env->active_tc.PC = env->active_tc.gpr[25] = ka->_sa_handler;
ea3164aa 3119 mips_set_hflags_isa_mode_from_pc(env);
0b1bcb00
PB		 3120 unlock_user_struct(frame, frame_addr, 1);
3121 return;
3122
3123give_sigsegv:
3124 unlock_user_struct(frame, frame_addr, 1);
3125 force_sig(TARGET_SIGSEGV/*, current*/);
106ec879
FB		 3126}
3127
05390248 3128long do_rt_sigreturn(CPUMIPSState *env)
106ec879 3129{
0b1bcb00
PB		 3130 struct target_rt_sigframe *frame;
3131 abi_ulong frame_addr;
3132 sigset_t blocked;
3133
3134#if defined(DEBUG_SIGNAL)
3135 fprintf(stderr, "do_rt_sigreturn\n");
3136#endif
3137 frame_addr = env->active_tc.gpr[29];
3138 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
3139 goto badframe;
3140
60e99246 3141 target_to_host_sigset(&blocked, &frame->rs_uc.tuc_sigmask);
1c275925 3142 do_sigprocmask(SIG_SETMASK, &blocked, NULL);
0b1bcb00 3143
60e99246 3144 if (restore_sigcontext(env, &frame->rs_uc.tuc_mcontext))
0b1bcb00
PB		 3145 goto badframe;
3146
3147 if (do_sigaltstack(frame_addr +
60e99246 3148 offsetof(struct target_rt_sigframe, rs_uc.tuc_stack),
0b1bcb00
PB		 3149 0, get_sp_from_cpustate(env)) == -EFAULT)
3150 goto badframe;
3151
3152 env->active_tc.PC = env->CP0_EPC;
ea3164aa 3153 mips_set_hflags_isa_mode_from_pc(env);
0b1bcb00
PB		 3154 /* I am not sure this is right, but it seems to work
3155 * maybe a problem with nested signals ? */
3156 env->CP0_EPC = 0;
3157 return -TARGET_QEMU_ESIGRETURN;
3158
3159badframe:
3160 force_sig(TARGET_SIGSEGV/*, current*/);
3161 return 0;
106ec879 3162}
6d5e216d 3163
c3b5bc8a
TS		 3164#elif defined(TARGET_SH4)
3165
3166/*
3167 * code and data structures from linux kernel:
3168 * include/asm-sh/sigcontext.h
3169 * arch/sh/kernel/signal.c
3170 */
3171
3172struct target_sigcontext {
3173 target_ulong oldmask;
3174
3175 /* CPU registers */
3176 target_ulong sc_gregs[16];
3177 target_ulong sc_pc;
3178 target_ulong sc_pr;
3179 target_ulong sc_sr;
3180 target_ulong sc_gbr;
3181 target_ulong sc_mach;
3182 target_ulong sc_macl;
3183
3184 /* FPU registers */
3185 target_ulong sc_fpregs[16];
3186 target_ulong sc_xfpregs[16];
3187 unsigned int sc_fpscr;
3188 unsigned int sc_fpul;
3189 unsigned int sc_ownedfp;
3190};
3191
3192struct target_sigframe
3193{
3194 struct target_sigcontext sc;
3195 target_ulong extramask[TARGET_NSIG_WORDS-1];
3196 uint16_t retcode[3];
3197};
3198
3199
3200struct target_ucontext {
60e99246
AJ		 3201 target_ulong tuc_flags;
3202 struct target_ucontext *tuc_link;
3203 target_stack_t tuc_stack;
3204 struct target_sigcontext tuc_mcontext;
3205 target_sigset_t tuc_sigmask; /* mask last for extensibility */
c3b5bc8a
TS		 3206};
3207
3208struct target_rt_sigframe
3209{
3210 struct target_siginfo info;
3211 struct target_ucontext uc;
3212 uint16_t retcode[3];
3213};
3214
3215
3216#define MOVW(n) (0x9300|((n)-2)) /* Move mem word at PC+n to R3 */
3217#define TRAP_NOARG 0xc310 /* Syscall w/no args (NR in R3) SH3/4 */
3218
624f7979 3219static abi_ulong get_sigframe(struct target_sigaction *ka,
c3b5bc8a
TS		 3220 unsigned long sp, size_t frame_size)
3221{
624f7979 3222 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags(sp) == 0)) {
c3b5bc8a
TS		 3223 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
3224 }
3225
3226 return (sp - frame_size) & -8ul;
3227}
3228
3229static int setup_sigcontext(struct target_sigcontext *sc,
05390248 3230 CPUSH4State *regs, unsigned long mask)
c3b5bc8a
TS		 3231{
3232 int err = 0;
d8714436 3233 int i;
c3b5bc8a 3234
1d8b512b 3235#define COPY(x) __put_user(regs->x, &sc->sc_##x)
c3b5bc8a
TS		 3236 COPY(gregs[0]); COPY(gregs[1]);
3237 COPY(gregs[2]); COPY(gregs[3]);
3238 COPY(gregs[4]); COPY(gregs[5]);
3239 COPY(gregs[6]); COPY(gregs[7]);
3240 COPY(gregs[8]); COPY(gregs[9]);
3241 COPY(gregs[10]); COPY(gregs[11]);
3242 COPY(gregs[12]); COPY(gregs[13]);
3243 COPY(gregs[14]); COPY(gregs[15]);
3244 COPY(gbr); COPY(mach);
3245 COPY(macl); COPY(pr);
3246 COPY(sr); COPY(pc);
3247#undef COPY
3248
d8714436 3249 for (i=0; i<16; i++) {
1d8b512b 3250 __put_user(regs->fregs[i], &sc->sc_fpregs[i]);
d8714436 3251 }
1d8b512b
RV		 3252 __put_user(regs->fpscr, &sc->sc_fpscr);
3253 __put_user(regs->fpul, &sc->sc_fpul);
c3b5bc8a
TS		 3254
3255 /* non-iBCS2 extensions.. */
1d8b512b 3256 __put_user(mask, &sc->oldmask);
c3b5bc8a
TS		 3257
3258 return err;
3259}
3260
05390248 3261static int restore_sigcontext(CPUSH4State *regs, struct target_sigcontext *sc,
d8714436 3262 target_ulong *r0_p)
c3b5bc8a
TS		 3263{
3264 unsigned int err = 0;
d8714436 3265 int i;
c3b5bc8a 3266
1d8b512b 3267#define COPY(x) __get_user(regs->x, &sc->sc_##x)
c3b5bc8a
TS		 3268 COPY(gregs[1]);
3269 COPY(gregs[2]); COPY(gregs[3]);
3270 COPY(gregs[4]); COPY(gregs[5]);
3271 COPY(gregs[6]); COPY(gregs[7]);
3272 COPY(gregs[8]); COPY(gregs[9]);
3273 COPY(gregs[10]); COPY(gregs[11]);
3274 COPY(gregs[12]); COPY(gregs[13]);
3275 COPY(gregs[14]); COPY(gregs[15]);
3276 COPY(gbr); COPY(mach);
3277 COPY(macl); COPY(pr);
3278 COPY(sr); COPY(pc);
3279#undef COPY
3280
d8714436 3281 for (i=0; i<16; i++) {
1d8b512b 3282 __get_user(regs->fregs[i], &sc->sc_fpregs[i]);
d8714436 3283 }
1d8b512b
RV		 3284 __get_user(regs->fpscr, &sc->sc_fpscr);
3285 __get_user(regs->fpul, &sc->sc_fpul);
c3b5bc8a
TS		 3286
3287 regs->tra = -1; /* disable syscall checks */
1d8b512b 3288 __get_user(*r0_p, &sc->sc_gregs[0]);
c3b5bc8a
TS		 3289 return err;
3290}
3291
624f7979 3292static void setup_frame(int sig, struct target_sigaction *ka,
05390248 3293 target_sigset_t *set, CPUSH4State *regs)
c3b5bc8a
TS		 3294{
3295 struct target_sigframe *frame;
3296 abi_ulong frame_addr;
3297 int i;
3298 int err = 0;
3299 int signal;
3300
3301 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
3302 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3303 goto give_sigsegv;
3304
3305 signal = current_exec_domain_sig(sig);
3306
3307 err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
3308
3309 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
1d8b512b 3310 __put_user(set->sig[i + 1], &frame->extramask[i]);
c3b5bc8a
TS		 3311 }
3312
3313 /* Set up to return from userspace. If provided, use a stub
3314 already in userspace. */
624f7979
PB		 3315 if (ka->sa_flags & TARGET_SA_RESTORER) {
3316 regs->pr = (unsigned long) ka->sa_restorer;
c3b5bc8a
TS		 3317 } else {
3318 /* Generate return code (system call to sigreturn) */
1d8b512b
RV		 3319 __put_user(MOVW(2), &frame->retcode[0]);
3320 __put_user(TRAP_NOARG, &frame->retcode[1]);
3321 __put_user((TARGET_NR_sigreturn), &frame->retcode[2]);
c3b5bc8a
TS		 3322 regs->pr = (unsigned long) frame->retcode;
3323 }
3324
3325 if (err)
3326 goto give_sigsegv;
3327
3328 /* Set up registers for signal handler */
cb9c6268 3329 regs->gregs[15] = frame_addr;
c3b5bc8a
TS		 3330 regs->gregs[4] = signal; /* Arg for signal handler */
3331 regs->gregs[5] = 0;
cb9c6268 3332 regs->gregs[6] = frame_addr += offsetof(typeof(*frame), sc);
624f7979 3333 regs->pc = (unsigned long) ka->_sa_handler;
c3b5bc8a
TS		 3334
3335 unlock_user_struct(frame, frame_addr, 1);
3336 return;
3337
3338give_sigsegv:
3339 unlock_user_struct(frame, frame_addr, 1);
66393fb9 3340 force_sig(TARGET_SIGSEGV);
c3b5bc8a
TS		 3341}
3342
624f7979 3343static void setup_rt_frame(int sig, struct target_sigaction *ka,
c227f099 3344 target_siginfo_t *info,
05390248 3345 target_sigset_t *set, CPUSH4State *regs)
c3b5bc8a
TS		 3346{
3347 struct target_rt_sigframe *frame;
3348 abi_ulong frame_addr;
3349 int i;
3350 int err = 0;
3351 int signal;
3352
3353 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
3354 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3355 goto give_sigsegv;
3356
3357 signal = current_exec_domain_sig(sig);
3358
b0fd8d18 3359 copy_siginfo_to_user(&frame->info, info);
c3b5bc8a
TS		 3360
3361 /* Create the ucontext. */
1d8b512b
RV		 3362 __put_user(0, &frame->uc.tuc_flags);
3363 __put_user(0, (unsigned long *)&frame->uc.tuc_link);
3364 __put_user((unsigned long)target_sigaltstack_used.ss_sp,
3365 &frame->uc.tuc_stack.ss_sp);
3366 __put_user(sas_ss_flags(regs->gregs[15]),
3367 &frame->uc.tuc_stack.ss_flags);
3368 __put_user(target_sigaltstack_used.ss_size,
3369 &frame->uc.tuc_stack.ss_size);
3370 setup_sigcontext(&frame->uc.tuc_mcontext,
c3b5bc8a
TS		 3371 regs, set->sig[0]);
3372 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1d8b512b 3373 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
c3b5bc8a
TS		 3374 }
3375
3376 /* Set up to return from userspace. If provided, use a stub
3377 already in userspace. */
624f7979
PB		 3378 if (ka->sa_flags & TARGET_SA_RESTORER) {
3379 regs->pr = (unsigned long) ka->sa_restorer;
c3b5bc8a
TS		 3380 } else {
3381 /* Generate return code (system call to sigreturn) */
1d8b512b
RV		 3382 __put_user(MOVW(2), &frame->retcode[0]);
3383 __put_user(TRAP_NOARG, &frame->retcode[1]);
3384 __put_user((TARGET_NR_rt_sigreturn), &frame->retcode[2]);
c3b5bc8a
TS		 3385 regs->pr = (unsigned long) frame->retcode;
3386 }
3387
3388 if (err)
3389 goto give_sigsegv;
3390
3391 /* Set up registers for signal handler */
cb9c6268 3392 regs->gregs[15] = frame_addr;
c3b5bc8a 3393 regs->gregs[4] = signal; /* Arg for signal handler */
cb9c6268
EI		 3394 regs->gregs[5] = frame_addr + offsetof(typeof(*frame), info);
3395 regs->gregs[6] = frame_addr + offsetof(typeof(*frame), uc);
624f7979 3396 regs->pc = (unsigned long) ka->_sa_handler;
c3b5bc8a
TS		 3397
3398 unlock_user_struct(frame, frame_addr, 1);
3399 return;
3400
3401give_sigsegv:
3402 unlock_user_struct(frame, frame_addr, 1);
66393fb9 3403 force_sig(TARGET_SIGSEGV);
c3b5bc8a
TS		 3404}
3405
05390248 3406long do_sigreturn(CPUSH4State *regs)
c3b5bc8a
TS		 3407{
3408 struct target_sigframe *frame;
3409 abi_ulong frame_addr;
3410 sigset_t blocked;
c227f099 3411 target_sigset_t target_set;
d8714436 3412 target_ulong r0;
c3b5bc8a
TS		 3413 int i;
3414 int err = 0;
3415
3416#if defined(DEBUG_SIGNAL)
3417 fprintf(stderr, "do_sigreturn\n");
3418#endif
3419 frame_addr = regs->gregs[15];
3420 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
3421 goto badframe;
3422
1d8b512b 3423 __get_user(target_set.sig[0], &frame->sc.oldmask);
c3b5bc8a 3424 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1d8b512b 3425 __get_user(target_set.sig[i], &frame->extramask[i - 1]);
c3b5bc8a
TS		 3426 }
3427
3428 if (err)
3429 goto badframe;
3430
3431 target_to_host_sigset_internal(&blocked, &target_set);
1c275925 3432 do_sigprocmask(SIG_SETMASK, &blocked, NULL);
c3b5bc8a 3433
d8714436 3434 if (restore_sigcontext(regs, &frame->sc, &r0))
c3b5bc8a
TS		 3435 goto badframe;
3436
3437 unlock_user_struct(frame, frame_addr, 0);
d8714436 3438 return r0;
c3b5bc8a
TS		 3439
3440badframe:
3441 unlock_user_struct(frame, frame_addr, 0);
3442 force_sig(TARGET_SIGSEGV);
3443 return 0;
3444}
3445
05390248 3446long do_rt_sigreturn(CPUSH4State *regs)
c3b5bc8a
TS		 3447{
3448 struct target_rt_sigframe *frame;
3449 abi_ulong frame_addr;
3450 sigset_t blocked;
d8714436 3451 target_ulong r0;
c3b5bc8a
TS		 3452
3453#if defined(DEBUG_SIGNAL)
3454 fprintf(stderr, "do_rt_sigreturn\n");
3455#endif
3456 frame_addr = regs->gregs[15];
3457 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
3458 goto badframe;
3459
60e99246 3460 target_to_host_sigset(&blocked, &frame->uc.tuc_sigmask);
1c275925 3461 do_sigprocmask(SIG_SETMASK, &blocked, NULL);
c3b5bc8a 3462
60e99246 3463 if (restore_sigcontext(regs, &frame->uc.tuc_mcontext, &r0))
c3b5bc8a
TS		 3464 goto badframe;
3465
3466 if (do_sigaltstack(frame_addr +
60e99246 3467 offsetof(struct target_rt_sigframe, uc.tuc_stack),
c3b5bc8a
TS		 3468 0, get_sp_from_cpustate(regs)) == -EFAULT)
3469 goto badframe;
3470
3471 unlock_user_struct(frame, frame_addr, 0);
d8714436 3472 return r0;
c3b5bc8a
TS		 3473
3474badframe:
3475 unlock_user_struct(frame, frame_addr, 0);
3476 force_sig(TARGET_SIGSEGV);
3477 return 0;
3478}
b779e29e
EI		 3479#elif defined(TARGET_MICROBLAZE)
3480
3481struct target_sigcontext {
3482 struct target_pt_regs regs; /* needs to be first */
3483 uint32_t oldmask;
3484};
3485
b2178704
EI		 3486struct target_stack_t {
3487 abi_ulong ss_sp;
3488 int ss_flags;
3489 unsigned int ss_size;
3490};
3491
3492struct target_ucontext {
f711df67
RH		 3493 abi_ulong tuc_flags;
3494 abi_ulong tuc_link;
3495 struct target_stack_t tuc_stack;
3496 struct target_sigcontext tuc_mcontext;
3497 uint32_t tuc_extramask[TARGET_NSIG_WORDS - 1];
b2178704
EI		 3498};
3499
b779e29e
EI		 3500/* Signal frames. */
3501struct target_signal_frame {
b2178704 3502 struct target_ucontext uc;
b779e29e
EI		 3503 uint32_t extramask[TARGET_NSIG_WORDS - 1];
3504 uint32_t tramp[2];
3505};
3506
3507struct rt_signal_frame {
02d2bd5d 3508 siginfo_t info;
b779e29e
EI		 3509 struct ucontext uc;
3510 uint32_t tramp[2];
3511};
3512
05390248 3513static void setup_sigcontext(struct target_sigcontext *sc, CPUMBState *env)
b779e29e
EI		 3514{
3515 __put_user(env->regs[0], &sc->regs.r0);
3516 __put_user(env->regs[1], &sc->regs.r1);
3517 __put_user(env->regs[2], &sc->regs.r2);
3518 __put_user(env->regs[3], &sc->regs.r3);
3519 __put_user(env->regs[4], &sc->regs.r4);
3520 __put_user(env->regs[5], &sc->regs.r5);
3521 __put_user(env->regs[6], &sc->regs.r6);
3522 __put_user(env->regs[7], &sc->regs.r7);
3523 __put_user(env->regs[8], &sc->regs.r8);
3524 __put_user(env->regs[9], &sc->regs.r9);
3525 __put_user(env->regs[10], &sc->regs.r10);
3526 __put_user(env->regs[11], &sc->regs.r11);
3527 __put_user(env->regs[12], &sc->regs.r12);
3528 __put_user(env->regs[13], &sc->regs.r13);
3529 __put_user(env->regs[14], &sc->regs.r14);
3530 __put_user(env->regs[15], &sc->regs.r15);
3531 __put_user(env->regs[16], &sc->regs.r16);
3532 __put_user(env->regs[17], &sc->regs.r17);
3533 __put_user(env->regs[18], &sc->regs.r18);
3534 __put_user(env->regs[19], &sc->regs.r19);
3535 __put_user(env->regs[20], &sc->regs.r20);
3536 __put_user(env->regs[21], &sc->regs.r21);
3537 __put_user(env->regs[22], &sc->regs.r22);
3538 __put_user(env->regs[23], &sc->regs.r23);
3539 __put_user(env->regs[24], &sc->regs.r24);
3540 __put_user(env->regs[25], &sc->regs.r25);
3541 __put_user(env->regs[26], &sc->regs.r26);
3542 __put_user(env->regs[27], &sc->regs.r27);
3543 __put_user(env->regs[28], &sc->regs.r28);
3544 __put_user(env->regs[29], &sc->regs.r29);
3545 __put_user(env->regs[30], &sc->regs.r30);
3546 __put_user(env->regs[31], &sc->regs.r31);
3547 __put_user(env->sregs[SR_PC], &sc->regs.pc);
3548}
3549
05390248 3550static void restore_sigcontext(struct target_sigcontext *sc, CPUMBState *env)
b779e29e
EI		 3551{
3552 __get_user(env->regs[0], &sc->regs.r0);
3553 __get_user(env->regs[1], &sc->regs.r1);
3554 __get_user(env->regs[2], &sc->regs.r2);
3555 __get_user(env->regs[3], &sc->regs.r3);
3556 __get_user(env->regs[4], &sc->regs.r4);
3557 __get_user(env->regs[5], &sc->regs.r5);
3558 __get_user(env->regs[6], &sc->regs.r6);
3559 __get_user(env->regs[7], &sc->regs.r7);
3560 __get_user(env->regs[8], &sc->regs.r8);
3561 __get_user(env->regs[9], &sc->regs.r9);
3562 __get_user(env->regs[10], &sc->regs.r10);
3563 __get_user(env->regs[11], &sc->regs.r11);
3564 __get_user(env->regs[12], &sc->regs.r12);
3565 __get_user(env->regs[13], &sc->regs.r13);
3566 __get_user(env->regs[14], &sc->regs.r14);
3567 __get_user(env->regs[15], &sc->regs.r15);
3568 __get_user(env->regs[16], &sc->regs.r16);
3569 __get_user(env->regs[17], &sc->regs.r17);
3570 __get_user(env->regs[18], &sc->regs.r18);
3571 __get_user(env->regs[19], &sc->regs.r19);
3572 __get_user(env->regs[20], &sc->regs.r20);
3573 __get_user(env->regs[21], &sc->regs.r21);
3574 __get_user(env->regs[22], &sc->regs.r22);
3575 __get_user(env->regs[23], &sc->regs.r23);
3576 __get_user(env->regs[24], &sc->regs.r24);
3577 __get_user(env->regs[25], &sc->regs.r25);
3578 __get_user(env->regs[26], &sc->regs.r26);
3579 __get_user(env->regs[27], &sc->regs.r27);
3580 __get_user(env->regs[28], &sc->regs.r28);
3581 __get_user(env->regs[29], &sc->regs.r29);
3582 __get_user(env->regs[30], &sc->regs.r30);
3583 __get_user(env->regs[31], &sc->regs.r31);
3584 __get_user(env->sregs[SR_PC], &sc->regs.pc);
3585}
3586
3587static abi_ulong get_sigframe(struct target_sigaction *ka,
05390248 3588 CPUMBState *env, int frame_size)
b779e29e
EI		 3589{
3590 abi_ulong sp = env->regs[1];
3591
3592 if ((ka->sa_flags & SA_ONSTACK) != 0 && !on_sig_stack(sp))
3593 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
3594
3595 return ((sp - frame_size) & -8UL);
3596}
3597
3598static void setup_frame(int sig, struct target_sigaction *ka,
05390248 3599 target_sigset_t *set, CPUMBState *env)
b779e29e
EI		 3600{
3601 struct target_signal_frame *frame;
3602 abi_ulong frame_addr;
3603 int err = 0;
3604 int i;
3605
3606 frame_addr = get_sigframe(ka, env, sizeof *frame);
3607 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3608 goto badframe;
3609
3610 /* Save the mask. */
1d8b512b 3611 __put_user(set->sig[0], &frame->uc.tuc_mcontext.oldmask);
b779e29e
EI		 3612 if (err)
3613 goto badframe;
3614
3615 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3616 if (__put_user(set->sig[i], &frame->extramask[i - 1]))
3617 goto badframe;
3618 }
3619
f711df67 3620 setup_sigcontext(&frame->uc.tuc_mcontext, env);
b779e29e
EI		 3621
3622 /* Set up to return from userspace. If provided, use a stub
3623 already in userspace. */
3624 /* minus 8 is offset to cater for "rtsd r15,8" offset */
3625 if (ka->sa_flags & TARGET_SA_RESTORER) {
3626 env->regs[15] = ((unsigned long)ka->sa_restorer)-8;
3627 } else {
3628 uint32_t t;
3629 /* Note, these encodings are _big endian_! */
3630 /* addi r12, r0, __NR_sigreturn */
3631 t = 0x31800000UL | TARGET_NR_sigreturn;
1d8b512b 3632 __put_user(t, frame->tramp + 0);
b779e29e
EI		 3633 /* brki r14, 0x8 */
3634 t = 0xb9cc0008UL;
1d8b512b 3635 __put_user(t, frame->tramp + 1);
b779e29e
EI		 3636
3637 /* Return from sighandler will jump to the tramp.
3638 Negative 8 offset because return is rtsd r15, 8 */
3639 env->regs[15] = ((unsigned long)frame->tramp) - 8;
3640 }
3641
3642 if (err)
3643 goto badframe;
3644
3645 /* Set up registers for signal handler */
cb9c6268 3646 env->regs[1] = frame_addr;
b779e29e
EI		 3647 /* Signal handler args: */
3648 env->regs[5] = sig; /* Arg 0: signum */
187b4e08 3649 env->regs[6] = 0;
cb9c6268
EI		 3650 /* arg 1: sigcontext */
3651 env->regs[7] = frame_addr += offsetof(typeof(*frame), uc);
b779e29e
EI		 3652
3653 /* Offset of 4 to handle microblaze rtid r14, 0 */
3654 env->sregs[SR_PC] = (unsigned long)ka->_sa_handler;
3655
3656 unlock_user_struct(frame, frame_addr, 1);
3657 return;
3658 badframe:
3659 unlock_user_struct(frame, frame_addr, 1);
3660 force_sig(TARGET_SIGSEGV);
3661}
3662
3663static void setup_rt_frame(int sig, struct target_sigaction *ka,
c227f099 3664 target_siginfo_t *info,
05390248 3665 target_sigset_t *set, CPUMBState *env)
b779e29e
EI		 3666{
3667 fprintf(stderr, "Microblaze setup_rt_frame: not implemented\n");
3668}
3669
05390248 3670long do_sigreturn(CPUMBState *env)
b779e29e
EI		 3671{
3672 struct target_signal_frame *frame;
3673 abi_ulong frame_addr;
c227f099 3674 target_sigset_t target_set;
b779e29e
EI		 3675 sigset_t set;
3676 int i;
3677
3678 frame_addr = env->regs[R_SP];
3679 /* Make sure the guest isn't playing games. */
3680 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
3681 goto badframe;
3682
3683 /* Restore blocked signals */
f711df67 3684 if (__get_user(target_set.sig[0], &frame->uc.tuc_mcontext.oldmask))
b779e29e
EI		 3685 goto badframe;
3686 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3687 if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
3688 goto badframe;
3689 }
3690 target_to_host_sigset_internal(&set, &target_set);
1c275925 3691 do_sigprocmask(SIG_SETMASK, &set, NULL);
b779e29e 3692
f711df67 3693 restore_sigcontext(&frame->uc.tuc_mcontext, env);
b779e29e
EI		 3694 /* We got here through a sigreturn syscall, our path back is via an
3695 rtb insn so setup r14 for that. */
3696 env->regs[14] = env->sregs[SR_PC];
3697
3698 unlock_user_struct(frame, frame_addr, 0);
3699 return env->regs[10];
3700 badframe:
3701 unlock_user_struct(frame, frame_addr, 0);
3702 force_sig(TARGET_SIGSEGV);
3703}
3704
05390248 3705long do_rt_sigreturn(CPUMBState *env)
b779e29e
EI		 3706{
3707 fprintf(stderr, "Microblaze do_rt_sigreturn: not implemented\n");
3708 return -TARGET_ENOSYS;
3709}
3710
b6d3abda
EI		 3711#elif defined(TARGET_CRIS)
3712
3713struct target_sigcontext {
3714 struct target_pt_regs regs; /* needs to be first */
3715 uint32_t oldmask;
3716 uint32_t usp; /* usp before stacking this gunk on it */
3717};
3718
3719/* Signal frames. */
3720struct target_signal_frame {
3721 struct target_sigcontext sc;
3722 uint32_t extramask[TARGET_NSIG_WORDS - 1];
8cfc114a 3723 uint16_t retcode[4]; /* Trampoline code. */
b6d3abda
EI		 3724};
3725
3726struct rt_signal_frame {
02d2bd5d 3727 siginfo_t *pinfo;
b6d3abda 3728 void *puc;
02d2bd5d 3729 siginfo_t info;
b6d3abda 3730 struct ucontext uc;
8cfc114a 3731 uint16_t retcode[4]; /* Trampoline code. */
b6d3abda
EI		 3732};
3733
05390248 3734static void setup_sigcontext(struct target_sigcontext *sc, CPUCRISState *env)
b6d3abda 3735{
9664d928
EI		 3736 __put_user(env->regs[0], &sc->regs.r0);
3737 __put_user(env->regs[1], &sc->regs.r1);
3738 __put_user(env->regs[2], &sc->regs.r2);
3739 __put_user(env->regs[3], &sc->regs.r3);
3740 __put_user(env->regs[4], &sc->regs.r4);
3741 __put_user(env->regs[5], &sc->regs.r5);
3742 __put_user(env->regs[6], &sc->regs.r6);
3743 __put_user(env->regs[7], &sc->regs.r7);
3744 __put_user(env->regs[8], &sc->regs.r8);
3745 __put_user(env->regs[9], &sc->regs.r9);
3746 __put_user(env->regs[10], &sc->regs.r10);
3747 __put_user(env->regs[11], &sc->regs.r11);
3748 __put_user(env->regs[12], &sc->regs.r12);
3749 __put_user(env->regs[13], &sc->regs.r13);
3750 __put_user(env->regs[14], &sc->usp);
3751 __put_user(env->regs[15], &sc->regs.acr);
3752 __put_user(env->pregs[PR_MOF], &sc->regs.mof);
3753 __put_user(env->pregs[PR_SRP], &sc->regs.srp);
3754 __put_user(env->pc, &sc->regs.erp);
b6d3abda 3755}
9664d928 3756
05390248 3757static void restore_sigcontext(struct target_sigcontext *sc, CPUCRISState *env)
b6d3abda 3758{
9664d928
EI		 3759 __get_user(env->regs[0], &sc->regs.r0);
3760 __get_user(env->regs[1], &sc->regs.r1);
3761 __get_user(env->regs[2], &sc->regs.r2);
3762 __get_user(env->regs[3], &sc->regs.r3);
3763 __get_user(env->regs[4], &sc->regs.r4);
3764 __get_user(env->regs[5], &sc->regs.r5);
3765 __get_user(env->regs[6], &sc->regs.r6);
3766 __get_user(env->regs[7], &sc->regs.r7);
3767 __get_user(env->regs[8], &sc->regs.r8);
3768 __get_user(env->regs[9], &sc->regs.r9);
3769 __get_user(env->regs[10], &sc->regs.r10);
3770 __get_user(env->regs[11], &sc->regs.r11);
3771 __get_user(env->regs[12], &sc->regs.r12);
3772 __get_user(env->regs[13], &sc->regs.r13);
3773 __get_user(env->regs[14], &sc->usp);
3774 __get_user(env->regs[15], &sc->regs.acr);
3775 __get_user(env->pregs[PR_MOF], &sc->regs.mof);
3776 __get_user(env->pregs[PR_SRP], &sc->regs.srp);
3777 __get_user(env->pc, &sc->regs.erp);
3778}
3779
05390248 3780static abi_ulong get_sigframe(CPUCRISState *env, int framesize)
9664d928
EI		 3781{
3782 abi_ulong sp;
b6d3abda 3783 /* Align the stack downwards to 4. */
9664d928
EI		 3784 sp = (env->regs[R_SP] & ~3);
3785 return sp - framesize;
b6d3abda
EI		 3786}
3787
624f7979 3788static void setup_frame(int sig, struct target_sigaction *ka,
05390248 3789 target_sigset_t *set, CPUCRISState *env)
b6d3abda
EI		 3790{
3791 struct target_signal_frame *frame;
9664d928 3792 abi_ulong frame_addr;
b6d3abda
EI		 3793 int err = 0;
3794 int i;
b6d3abda 3795
9664d928
EI		 3796 frame_addr = get_sigframe(env, sizeof *frame);
3797 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
b6d3abda
EI		 3798 goto badframe;
3799
3800 /*
3801 * The CRIS signal return trampoline. A real linux/CRIS kernel doesn't
3802 * use this trampoline anymore but it sets it up for GDB.
3803 * In QEMU, using the trampoline simplifies things a bit so we use it.
3804 *
3805 * This is movu.w __NR_sigreturn, r9; break 13;
3806 */
1d8b512b
RV		 3807 __put_user(0x9c5f, frame->retcode+0);
3808 __put_user(TARGET_NR_sigreturn,
3809 frame->retcode + 1);
3810 __put_user(0xe93d, frame->retcode + 2);
b6d3abda
EI		 3811
3812 /* Save the mask. */
1d8b512b 3813 __put_user(set->sig[0], &frame->sc.oldmask);
b6d3abda
EI		 3814 if (err)
3815 goto badframe;
3816
3817 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3818 if (__put_user(set->sig[i], &frame->extramask[i - 1]))
3819 goto badframe;
3820 }
3821
3822 setup_sigcontext(&frame->sc, env);
3823
3824 /* Move the stack and setup the arguments for the handler. */
cb9c6268 3825 env->regs[R_SP] = frame_addr;
b6d3abda 3826 env->regs[10] = sig;
624f7979 3827 env->pc = (unsigned long) ka->_sa_handler;
b6d3abda 3828 /* Link SRP so the guest returns through the trampoline. */
cb9c6268 3829 env->pregs[PR_SRP] = frame_addr + offsetof(typeof(*frame), retcode);
b6d3abda 3830
9664d928 3831 unlock_user_struct(frame, frame_addr, 1);
b6d3abda
EI		 3832 return;
3833 badframe:
9664d928 3834 unlock_user_struct(frame, frame_addr, 1);
b6d3abda
EI		 3835 force_sig(TARGET_SIGSEGV);
3836}
3837
624f7979 3838static void setup_rt_frame(int sig, struct target_sigaction *ka,
c227f099 3839 target_siginfo_t *info,
05390248 3840 target_sigset_t *set, CPUCRISState *env)
b6d3abda
EI		 3841{
3842 fprintf(stderr, "CRIS setup_rt_frame: not implemented\n");
3843}
3844
05390248 3845long do_sigreturn(CPUCRISState *env)
b6d3abda
EI		 3846{
3847 struct target_signal_frame *frame;
9664d928 3848 abi_ulong frame_addr;
c227f099 3849 target_sigset_t target_set;
b6d3abda
EI		 3850 sigset_t set;
3851 int i;
3852
9664d928 3853 frame_addr = env->regs[R_SP];
b6d3abda 3854 /* Make sure the guest isn't playing games. */
9664d928 3855 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
b6d3abda
EI		 3856 goto badframe;
3857
3858 /* Restore blocked signals */
3859 if (__get_user(target_set.sig[0], &frame->sc.oldmask))
3860 goto badframe;
3861 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3862 if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
3863 goto badframe;
3864 }
3865 target_to_host_sigset_internal(&set, &target_set);
1c275925 3866 do_sigprocmask(SIG_SETMASK, &set, NULL);
b6d3abda
EI		 3867
3868 restore_sigcontext(&frame->sc, env);
9664d928 3869 unlock_user_struct(frame, frame_addr, 0);
b6d3abda
EI		 3870 return env->regs[10];
3871 badframe:
9664d928 3872 unlock_user_struct(frame, frame_addr, 0);
b6d3abda
EI		 3873 force_sig(TARGET_SIGSEGV);
3874}
3875
05390248 3876long do_rt_sigreturn(CPUCRISState *env)
b6d3abda
EI		 3877{
3878 fprintf(stderr, "CRIS do_rt_sigreturn: not implemented\n");
3879 return -TARGET_ENOSYS;
3880}
c3b5bc8a 3881
d962783e
JL		 3882#elif defined(TARGET_OPENRISC)
3883
3884struct target_sigcontext {
3885 struct target_pt_regs regs;
3886 abi_ulong oldmask;
3887 abi_ulong usp;
3888};
3889
3890struct target_ucontext {
3891 abi_ulong tuc_flags;
3892 abi_ulong tuc_link;
3893 target_stack_t tuc_stack;
3894 struct target_sigcontext tuc_mcontext;
3895 target_sigset_t tuc_sigmask; /* mask last for extensibility */
3896};
3897
3898struct target_rt_sigframe {
3899 abi_ulong pinfo;
3900 uint64_t puc;
3901 struct target_siginfo info;
3902 struct target_sigcontext sc;
3903 struct target_ucontext uc;
3904 unsigned char retcode[16]; /* trampoline code */
3905};
3906
3907/* This is the asm-generic/ucontext.h version */
3908#if 0
3909static int restore_sigcontext(CPUOpenRISCState *regs,
3910 struct target_sigcontext *sc)
3911{
3912 unsigned int err = 0;
3913 unsigned long old_usp;
3914
3915 /* Alwys make any pending restarted system call return -EINTR */
3916 current_thread_info()->restart_block.fn = do_no_restart_syscall;
3917
3918 /* restore the regs from &sc->regs (same as sc, since regs is first)
3919 * (sc is already checked for VERIFY_READ since the sigframe was
3920 * checked in sys_sigreturn previously)
3921 */
3922
3923 if (copy_from_user(regs, &sc, sizeof(struct target_pt_regs))) {
3924 goto badframe;
3925 }
3926
3927 /* make sure the U-flag is set so user-mode cannot fool us */
3928
3929 regs->sr &= ~SR_SM;
3930
3931 /* restore the old USP as it was before we stacked the sc etc.
3932 * (we cannot just pop the sigcontext since we aligned the sp and
3933 * stuff after pushing it)
3934 */
3935
1d8b512b 3936 __get_user(old_usp, &sc->usp);
d962783e
JL		 3937 phx_signal("old_usp 0x%lx", old_usp);
3938
3939 __PHX__ REALLY /* ??? */
3940 wrusp(old_usp);
3941 regs->gpr[1] = old_usp;
3942
3943 /* TODO: the other ports use regs->orig_XX to disable syscall checks
3944 * after this completes, but we don't use that mechanism. maybe we can
3945 * use it now ?
3946 */
3947
3948 return err;
3949
3950badframe:
3951 return 1;
3952}
3953#endif
3954
3955/* Set up a signal frame. */
3956
3957static int setup_sigcontext(struct target_sigcontext *sc,
3958 CPUOpenRISCState *regs,
3959 unsigned long mask)
3960{
3961 int err = 0;
3962 unsigned long usp = regs->gpr[1];
3963
3964 /* copy the regs. they are first in sc so we can use sc directly */
3965
1d8b512b 3966 /*copy_to_user(&sc, regs, sizeof(struct target_pt_regs));*/
d962783e
JL		 3967
3968 /* Set the frametype to CRIS_FRAME_NORMAL for the execution of
3969 the signal handler. The frametype will be restored to its previous
3970 value in restore_sigcontext. */
3971 /*regs->frametype = CRIS_FRAME_NORMAL;*/
3972
3973 /* then some other stuff */
1d8b512b
RV		 3974 __put_user(mask, &sc->oldmask);
3975 __put_user(usp, &sc->usp); return err;
d962783e
JL		 3976}
3977
3978static inline unsigned long align_sigframe(unsigned long sp)
3979{
3980 unsigned long i;
3981 i = sp & ~3UL;
3982 return i;
3983}
3984
3985static inline abi_ulong get_sigframe(struct target_sigaction *ka,
3986 CPUOpenRISCState *regs,
3987 size_t frame_size)
3988{
3989 unsigned long sp = regs->gpr[1];
3990 int onsigstack = on_sig_stack(sp);
3991
3992 /* redzone */
3993 /* This is the X/Open sanctioned signal stack switching. */
3994 if ((ka->sa_flags & SA_ONSTACK) != 0 && !onsigstack) {
3995 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
3996 }
3997
3998 sp = align_sigframe(sp - frame_size);
3999
4000 /*
4001 * If we are on the alternate signal stack and would overflow it, don't.
4002 * Return an always-bogus address instead so we will die with SIGSEGV.
4003 */
4004
4005 if (onsigstack && !likely(on_sig_stack(sp))) {
4006 return -1L;
4007 }
4008
4009 return sp;
4010}
4011
4012static void setup_frame(int sig, struct target_sigaction *ka,
4013 target_sigset_t *set, CPUOpenRISCState *env)
4014{
4015 qemu_log("Not implement.\n");
4016}
4017
4018static void setup_rt_frame(int sig, struct target_sigaction *ka,
4019 target_siginfo_t *info,
4020 target_sigset_t *set, CPUOpenRISCState *env)
4021{
4022 int err = 0;
4023 abi_ulong frame_addr;
4024 unsigned long return_ip;
4025 struct target_rt_sigframe *frame;
4026 abi_ulong info_addr, uc_addr;
4027
d962783e
JL		 4028 frame_addr = get_sigframe(ka, env, sizeof(*frame));
4029 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
4030 goto give_sigsegv;
4031 }
4032
4033 info_addr = frame_addr + offsetof(struct target_rt_sigframe, info);
1d8b512b 4034 __put_user(info_addr, &frame->pinfo);
d962783e 4035 uc_addr = frame_addr + offsetof(struct target_rt_sigframe, uc);
1d8b512b 4036 __put_user(uc_addr, &frame->puc);
d962783e
JL		 4037
4038 if (ka->sa_flags & SA_SIGINFO) {
b0fd8d18 4039 copy_siginfo_to_user(&frame->info, info);
d962783e
JL		 4040 }
4041
4042 /*err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext));*/
1d8b512b
RV		 4043 __put_user(0, &frame->uc.tuc_flags);
4044 __put_user(0, &frame->uc.tuc_link);
4045 __put_user(target_sigaltstack_used.ss_sp,
4046 &frame->uc.tuc_stack.ss_sp);
4047 __put_user(sas_ss_flags(env->gpr[1]), &frame->uc.tuc_stack.ss_flags);
4048 __put_user(target_sigaltstack_used.ss_size,
4049 &frame->uc.tuc_stack.ss_size);
d962783e
JL		 4050 err |= setup_sigcontext(&frame->sc, env, set->sig[0]);
4051
4052 /*err |= copy_to_user(frame->uc.tuc_sigmask, set, sizeof(*set));*/
4053
4054 if (err) {
4055 goto give_sigsegv;
4056 }
4057
4058 /* trampoline - the desired return ip is the retcode itself */
4059 return_ip = (unsigned long)&frame->retcode;
4060 /* This is l.ori r11,r0,__NR_sigreturn, l.sys 1 */
1d8b512b
RV		 4061 __put_user(0xa960, (short *)(frame->retcode + 0));
4062 __put_user(TARGET_NR_rt_sigreturn, (short *)(frame->retcode + 2));
4063 __put_user(0x20000001, (unsigned long *)(frame->retcode + 4));
4064 __put_user(0x15000000, (unsigned long *)(frame->retcode + 8));
d962783e
JL		 4065
4066 if (err) {
4067 goto give_sigsegv;
4068 }
4069
4070 /* TODO what is the current->exec_domain stuff and invmap ? */
4071
4072 /* Set up registers for signal handler */
4073 env->pc = (unsigned long)ka->_sa_handler; /* what we enter NOW */
4074 env->gpr[9] = (unsigned long)return_ip; /* what we enter LATER */
4075 env->gpr[3] = (unsigned long)sig; /* arg 1: signo */
4076 env->gpr[4] = (unsigned long)&frame->info; /* arg 2: (siginfo_t*) */
4077 env->gpr[5] = (unsigned long)&frame->uc; /* arg 3: ucontext */
4078
4079 /* actually move the usp to reflect the stacked frame */
4080 env->gpr[1] = (unsigned long)frame;
4081
4082 return;
4083
4084give_sigsegv:
4085 unlock_user_struct(frame, frame_addr, 1);
4086 if (sig == TARGET_SIGSEGV) {
4087 ka->_sa_handler = TARGET_SIG_DFL;
4088 }
4089 force_sig(TARGET_SIGSEGV);
4090}
4091
4092long do_sigreturn(CPUOpenRISCState *env)
4093{
4094
4095 qemu_log("do_sigreturn: not implemented\n");
4096 return -TARGET_ENOSYS;
4097}
4098
4099long do_rt_sigreturn(CPUOpenRISCState *env)
4100{
4101 qemu_log("do_rt_sigreturn: not implemented\n");
4102 return -TARGET_ENOSYS;
4103}
4104/* TARGET_OPENRISC */
4105
a4c075f1
UH		 4106#elif defined(TARGET_S390X)
4107
4108#define __NUM_GPRS 16
4109#define __NUM_FPRS 16
4110#define __NUM_ACRS 16
4111
4112#define S390_SYSCALL_SIZE 2
4113#define __SIGNAL_FRAMESIZE 160 /* FIXME: 31-bit mode -> 96 */
4114
4115#define _SIGCONTEXT_NSIG 64
4116#define _SIGCONTEXT_NSIG_BPW 64 /* FIXME: 31-bit mode -> 32 */
4117#define _SIGCONTEXT_NSIG_WORDS (_SIGCONTEXT_NSIG / _SIGCONTEXT_NSIG_BPW)
4118#define _SIGMASK_COPY_SIZE (sizeof(unsigned long)*_SIGCONTEXT_NSIG_WORDS)
4119#define PSW_ADDR_AMODE 0x0000000000000000UL /* 0x80000000UL for 31-bit */
4120#define S390_SYSCALL_OPCODE ((uint16_t)0x0a00)
4121
4122typedef struct {
4123 target_psw_t psw;
4124 target_ulong gprs[__NUM_GPRS];
4125 unsigned int acrs[__NUM_ACRS];
4126} target_s390_regs_common;
4127
4128typedef struct {
4129 unsigned int fpc;
4130 double fprs[__NUM_FPRS];
4131} target_s390_fp_regs;
4132
4133typedef struct {
4134 target_s390_regs_common regs;
4135 target_s390_fp_regs fpregs;
4136} target_sigregs;
4137
4138struct target_sigcontext {
4139 target_ulong oldmask[_SIGCONTEXT_NSIG_WORDS];
4140 target_sigregs *sregs;
4141};
4142
4143typedef struct {
4144 uint8_t callee_used_stack[__SIGNAL_FRAMESIZE];
4145 struct target_sigcontext sc;
4146 target_sigregs sregs;
4147 int signo;
4148 uint8_t retcode[S390_SYSCALL_SIZE];
4149} sigframe;
4150
4151struct target_ucontext {
6fea2ea4
PM		 4152 target_ulong tuc_flags;
4153 struct target_ucontext *tuc_link;
4154 target_stack_t tuc_stack;
4155 target_sigregs tuc_mcontext;
4156 target_sigset_t tuc_sigmask; /* mask last for extensibility */
a4c075f1
UH		 4157};
4158
4159typedef struct {
4160 uint8_t callee_used_stack[__SIGNAL_FRAMESIZE];
4161 uint8_t retcode[S390_SYSCALL_SIZE];
4162 struct target_siginfo info;
4163 struct target_ucontext uc;
4164} rt_sigframe;
4165
4166static inline abi_ulong
05390248 4167get_sigframe(struct target_sigaction *ka, CPUS390XState *env, size_t frame_size)
a4c075f1
UH		 4168{
4169 abi_ulong sp;
4170
4171 /* Default to using normal stack */
4172 sp = env->regs[15];
4173
4174 /* This is the X/Open sanctioned signal stack switching. */
4175 if (ka->sa_flags & TARGET_SA_ONSTACK) {
4176 if (!sas_ss_flags(sp)) {
4177 sp = target_sigaltstack_used.ss_sp +
4178 target_sigaltstack_used.ss_size;
4179 }
4180 }
4181
4182 /* This is the legacy signal stack switching. */
4183 else if (/* FIXME !user_mode(regs) */ 0 &&
4184 !(ka->sa_flags & TARGET_SA_RESTORER) &&
4185 ka->sa_restorer) {
4186 sp = (abi_ulong) ka->sa_restorer;
4187 }
4188
4189 return (sp - frame_size) & -8ul;
4190}
4191
05390248 4192static void save_sigregs(CPUS390XState *env, target_sigregs *sregs)
a4c075f1
UH		 4193{
4194 int i;
4195 //save_access_regs(current->thread.acrs); FIXME
4196
4197 /* Copy a 'clean' PSW mask to the user to avoid leaking
4198 information about whether PER is currently on. */
4199 __put_user(env->psw.mask, &sregs->regs.psw.mask);
4200 __put_user(env->psw.addr, &sregs->regs.psw.addr);
4201 for (i = 0; i < 16; i++) {
4202 __put_user(env->regs[i], &sregs->regs.gprs[i]);
4203 }
4204 for (i = 0; i < 16; i++) {
4205 __put_user(env->aregs[i], &sregs->regs.acrs[i]);
4206 }
4207 /*
4208 * We have to store the fp registers to current->thread.fp_regs
4209 * to merge them with the emulated registers.
4210 */
4211 //save_fp_regs(&current->thread.fp_regs); FIXME
4212 for (i = 0; i < 16; i++) {
4213 __put_user(env->fregs[i].ll, &sregs->fpregs.fprs[i]);
4214 }
4215}
4216
4217static void setup_frame(int sig, struct target_sigaction *ka,
05390248 4218 target_sigset_t *set, CPUS390XState *env)
a4c075f1
UH		 4219{
4220 sigframe *frame;
4221 abi_ulong frame_addr;
4222
4223 frame_addr = get_sigframe(ka, env, sizeof(*frame));
4224 qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__,
4225 (unsigned long long)frame_addr);
4226 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
4227 goto give_sigsegv;
4228 }
4229
4230 qemu_log("%s: 1\n", __FUNCTION__);
4231 if (__put_user(set->sig[0], &frame->sc.oldmask[0])) {
4232 goto give_sigsegv;
4233 }
4234
4235 save_sigregs(env, &frame->sregs);
4236
4237 __put_user((abi_ulong)(unsigned long)&frame->sregs,
4238 (abi_ulong *)&frame->sc.sregs);
4239
4240 /* Set up to return from userspace. If provided, use a stub
4241 already in userspace. */
4242 if (ka->sa_flags & TARGET_SA_RESTORER) {
4243 env->regs[14] = (unsigned long)
4244 ka->sa_restorer | PSW_ADDR_AMODE;
4245 } else {
4246 env->regs[14] = (unsigned long)
4247 frame->retcode | PSW_ADDR_AMODE;
4248 if (__put_user(S390_SYSCALL_OPCODE | TARGET_NR_sigreturn,
4249 (uint16_t *)(frame->retcode)))
4250 goto give_sigsegv;
4251 }
4252
4253 /* Set up backchain. */
4254 if (__put_user(env->regs[15], (abi_ulong *) frame)) {
4255 goto give_sigsegv;
4256 }
4257
4258 /* Set up registers for signal handler */
cb9c6268 4259 env->regs[15] = frame_addr;
a4c075f1
UH		 4260 env->psw.addr = (target_ulong) ka->_sa_handler | PSW_ADDR_AMODE;
4261
4262 env->regs[2] = sig; //map_signal(sig);
cb9c6268 4263 env->regs[3] = frame_addr += offsetof(typeof(*frame), sc);
a4c075f1
UH		 4264
4265 /* We forgot to include these in the sigcontext.
4266 To avoid breaking binary compatibility, they are passed as args. */
4267 env->regs[4] = 0; // FIXME: no clue... current->thread.trap_no;
4268 env->regs[5] = 0; // FIXME: no clue... current->thread.prot_addr;
4269
4270 /* Place signal number on stack to allow backtrace from handler. */
4271 if (__put_user(env->regs[2], (int *) &frame->signo)) {
4272 goto give_sigsegv;
4273 }
4274 unlock_user_struct(frame, frame_addr, 1);
4275 return;
4276
4277give_sigsegv:
4278 qemu_log("%s: give_sigsegv\n", __FUNCTION__);
4279 unlock_user_struct(frame, frame_addr, 1);
4280 force_sig(TARGET_SIGSEGV);
4281}
4282
4283static void setup_rt_frame(int sig, struct target_sigaction *ka,
4284 target_siginfo_t *info,
05390248 4285 target_sigset_t *set, CPUS390XState *env)
a4c075f1
UH		 4286{
4287 int i;
4288 rt_sigframe *frame;
4289 abi_ulong frame_addr;
4290
4291 frame_addr = get_sigframe(ka, env, sizeof *frame);
4292 qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__,
4293 (unsigned long long)frame_addr);
4294 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
4295 goto give_sigsegv;
4296 }
4297
4298 qemu_log("%s: 1\n", __FUNCTION__);
b0fd8d18 4299 copy_siginfo_to_user(&frame->info, info);
a4c075f1
UH		 4300
4301 /* Create the ucontext. */
6fea2ea4
PM		 4302 __put_user(0, &frame->uc.tuc_flags);
4303 __put_user((abi_ulong)0, (abi_ulong *)&frame->uc.tuc_link);
4304 __put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp);
a4c075f1 4305 __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
6fea2ea4
PM		 4306 &frame->uc.tuc_stack.ss_flags);
4307 __put_user(target_sigaltstack_used.ss_size, &frame->uc.tuc_stack.ss_size);
4308 save_sigregs(env, &frame->uc.tuc_mcontext);
a4c075f1
UH		 4309 for (i = 0; i < TARGET_NSIG_WORDS; i++) {
4310 __put_user((abi_ulong)set->sig[i],
6fea2ea4 4311 (abi_ulong *)&frame->uc.tuc_sigmask.sig[i]);
a4c075f1
UH		 4312 }
4313
4314 /* Set up to return from userspace. If provided, use a stub
4315 already in userspace. */
4316 if (ka->sa_flags & TARGET_SA_RESTORER) {
4317 env->regs[14] = (unsigned long) ka->sa_restorer | PSW_ADDR_AMODE;
4318 } else {
4319 env->regs[14] = (unsigned long) frame->retcode | PSW_ADDR_AMODE;
4320 if (__put_user(S390_SYSCALL_OPCODE | TARGET_NR_rt_sigreturn,
4321 (uint16_t *)(frame->retcode))) {
4322 goto give_sigsegv;
4323 }
4324 }
4325
4326 /* Set up backchain. */
4327 if (__put_user(env->regs[15], (abi_ulong *) frame)) {
4328 goto give_sigsegv;
4329 }
4330
4331 /* Set up registers for signal handler */
cb9c6268 4332 env->regs[15] = frame_addr;
a4c075f1
UH		 4333 env->psw.addr = (target_ulong) ka->_sa_handler | PSW_ADDR_AMODE;
4334
4335 env->regs[2] = sig; //map_signal(sig);
cb9c6268
EI		 4336 env->regs[3] = frame_addr + offsetof(typeof(*frame), info);
4337 env->regs[4] = frame_addr + offsetof(typeof(*frame), uc);
a4c075f1
UH		 4338 return;
4339
4340give_sigsegv:
4341 qemu_log("%s: give_sigsegv\n", __FUNCTION__);
4342 unlock_user_struct(frame, frame_addr, 1);
4343 force_sig(TARGET_SIGSEGV);
4344}
4345
4346static int
05390248 4347restore_sigregs(CPUS390XState *env, target_sigregs *sc)
a4c075f1
UH		 4348{
4349 int err = 0;
4350 int i;
4351
4352 for (i = 0; i < 16; i++) {
1d8b512b 4353 __get_user(env->regs[i], &sc->regs.gprs[i]);
a4c075f1
UH		 4354 }
4355
1d8b512b 4356 __get_user(env->psw.mask, &sc->regs.psw.mask);
a4c075f1
UH		 4357 qemu_log("%s: sc->regs.psw.addr 0x%llx env->psw.addr 0x%llx\n",
4358 __FUNCTION__, (unsigned long long)sc->regs.psw.addr,
4359 (unsigned long long)env->psw.addr);
1d8b512b 4360 __get_user(env->psw.addr, &sc->regs.psw.addr);
a4c075f1
UH		 4361 /* FIXME: 31-bit -> | PSW_ADDR_AMODE */
4362
4363 for (i = 0; i < 16; i++) {
1d8b512b 4364 __get_user(env->aregs[i], &sc->regs.acrs[i]);
a4c075f1
UH		 4365 }
4366 for (i = 0; i < 16; i++) {
1d8b512b 4367 __get_user(env->fregs[i].ll, &sc->fpregs.fprs[i]);
a4c075f1
UH		 4368 }
4369
4370 return err;
4371}
4372
05390248 4373long do_sigreturn(CPUS390XState *env)
a4c075f1
UH		 4374{
4375 sigframe *frame;
4376 abi_ulong frame_addr = env->regs[15];
4377 qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__,
4378 (unsigned long long)frame_addr);
4379 target_sigset_t target_set;
4380 sigset_t set;
4381
4382 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
4383 goto badframe;
4384 }
4385 if (__get_user(target_set.sig[0], &frame->sc.oldmask[0])) {
4386 goto badframe;
4387 }
4388
4389 target_to_host_sigset_internal(&set, &target_set);
1c275925 4390 do_sigprocmask(SIG_SETMASK, &set, NULL); /* ~_BLOCKABLE? */
a4c075f1
UH		 4391
4392 if (restore_sigregs(env, &frame->sregs)) {
4393 goto badframe;
4394 }
4395
4396 unlock_user_struct(frame, frame_addr, 0);
4397 return env->regs[2];
4398
4399badframe:
4400 unlock_user_struct(frame, frame_addr, 0);
4401 force_sig(TARGET_SIGSEGV);
4402 return 0;
4403}
4404
05390248 4405long do_rt_sigreturn(CPUS390XState *env)
a4c075f1
UH		 4406{
4407 rt_sigframe *frame;
4408 abi_ulong frame_addr = env->regs[15];
4409 qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__,
4410 (unsigned long long)frame_addr);
4411 sigset_t set;
4412
4413 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
4414 goto badframe;
4415 }
6fea2ea4 4416 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
a4c075f1 4417
1c275925 4418 do_sigprocmask(SIG_SETMASK, &set, NULL); /* ~_BLOCKABLE? */
a4c075f1 4419
6fea2ea4 4420 if (restore_sigregs(env, &frame->uc.tuc_mcontext)) {
a4c075f1
UH		 4421 goto badframe;
4422 }
4423
6fea2ea4 4424 if (do_sigaltstack(frame_addr + offsetof(rt_sigframe, uc.tuc_stack), 0,
a4c075f1
UH		 4425 get_sp_from_cpustate(env)) == -EFAULT) {
4426 goto badframe;
4427 }
4428 unlock_user_struct(frame, frame_addr, 0);
4429 return env->regs[2];
4430
4431badframe:
4432 unlock_user_struct(frame, frame_addr, 0);
4433 force_sig(TARGET_SIGSEGV);
4434 return 0;
4435}
4436
bcd4933a
NF		 4437#elif defined(TARGET_PPC) && !defined(TARGET_PPC64)
4438
4439/* FIXME: Many of the structures are defined for both PPC and PPC64, but
4440 the signal handling is different enough that we haven't implemented
4441 support for PPC64 yet. Hence the restriction above.
4442
4443 There are various #if'd blocks for code for TARGET_PPC64. These
4444 blocks should go away so that we can successfully run 32-bit and
4445 64-bit binaries on a QEMU configured for PPC64. */
4446
4447/* Size of dummy stack frame allocated when calling signal handler.
4448 See arch/powerpc/include/asm/ptrace.h. */
4449#if defined(TARGET_PPC64)
4450#define SIGNAL_FRAMESIZE 128
4451#else
4452#define SIGNAL_FRAMESIZE 64
4453#endif
4454
4455/* See arch/powerpc/include/asm/sigcontext.h. */
4456struct target_sigcontext {
4457 target_ulong _unused[4];
4458 int32_t signal;
4459#if defined(TARGET_PPC64)
4460 int32_t pad0;
4461#endif
4462 target_ulong handler;
4463 target_ulong oldmask;
4464 target_ulong regs; /* struct pt_regs __user * */
4465 /* TODO: PPC64 includes extra bits here. */
4466};
4467
4468/* Indices for target_mcontext.mc_gregs, below.
4469 See arch/powerpc/include/asm/ptrace.h for details. */
4470enum {
4471 TARGET_PT_R0 = 0,
4472 TARGET_PT_R1 = 1,
4473 TARGET_PT_R2 = 2,
4474 TARGET_PT_R3 = 3,
4475 TARGET_PT_R4 = 4,
4476 TARGET_PT_R5 = 5,
4477 TARGET_PT_R6 = 6,
4478 TARGET_PT_R7 = 7,
4479 TARGET_PT_R8 = 8,
4480 TARGET_PT_R9 = 9,
4481 TARGET_PT_R10 = 10,
4482 TARGET_PT_R11 = 11,
4483 TARGET_PT_R12 = 12,
4484 TARGET_PT_R13 = 13,
4485 TARGET_PT_R14 = 14,
4486 TARGET_PT_R15 = 15,
4487 TARGET_PT_R16 = 16,
4488 TARGET_PT_R17 = 17,
4489 TARGET_PT_R18 = 18,
4490 TARGET_PT_R19 = 19,
4491 TARGET_PT_R20 = 20,
4492 TARGET_PT_R21 = 21,
4493 TARGET_PT_R22 = 22,
4494 TARGET_PT_R23 = 23,
4495 TARGET_PT_R24 = 24,
4496 TARGET_PT_R25 = 25,
4497 TARGET_PT_R26 = 26,
4498 TARGET_PT_R27 = 27,
4499 TARGET_PT_R28 = 28,
4500 TARGET_PT_R29 = 29,
4501 TARGET_PT_R30 = 30,
4502 TARGET_PT_R31 = 31,
4503 TARGET_PT_NIP = 32,
4504 TARGET_PT_MSR = 33,
4505 TARGET_PT_ORIG_R3 = 34,
4506 TARGET_PT_CTR = 35,
4507 TARGET_PT_LNK = 36,
4508 TARGET_PT_XER = 37,
4509 TARGET_PT_CCR = 38,
4510 /* Yes, there are two registers with #39. One is 64-bit only. */
4511 TARGET_PT_MQ = 39,
4512 TARGET_PT_SOFTE = 39,
4513 TARGET_PT_TRAP = 40,
4514 TARGET_PT_DAR = 41,
4515 TARGET_PT_DSISR = 42,
4516 TARGET_PT_RESULT = 43,
4517 TARGET_PT_REGS_COUNT = 44
4518};
4519
4520/* See arch/powerpc/include/asm/ucontext.h. Only used for 32-bit PPC;
4521 on 64-bit PPC, sigcontext and mcontext are one and the same. */
4522struct target_mcontext {
4523 target_ulong mc_gregs[48];
4524 /* Includes fpscr. */
4525 uint64_t mc_fregs[33];
4526 target_ulong mc_pad[2];
4527 /* We need to handle Altivec and SPE at the same time, which no
4528 kernel needs to do. Fortunately, the kernel defines this bit to
4529 be Altivec-register-large all the time, rather than trying to
4530 twiddle it based on the specific platform. */
4531 union {
4532 /* SPE vector registers. One extra for SPEFSCR. */
4533 uint32_t spe[33];
4534 /* Altivec vector registers. The packing of VSCR and VRSAVE
4535 varies depending on whether we're PPC64 or not: PPC64 splits
4536 them apart; PPC32 stuffs them together. */
4537#if defined(TARGET_PPC64)
3efa9a67 4538#define QEMU_NVRREG 34
bcd4933a 4539#else
3efa9a67 4540#define QEMU_NVRREG 33
bcd4933a 4541#endif
c227f099 4542 ppc_avr_t altivec[QEMU_NVRREG];
3efa9a67 4543#undef QEMU_NVRREG
bcd4933a
NF		 4544 } mc_vregs __attribute__((__aligned__(16)));
4545};
4546
4547struct target_ucontext {
60e99246
AJ		 4548 target_ulong tuc_flags;
4549 target_ulong tuc_link; /* struct ucontext __user * */
4550 struct target_sigaltstack tuc_stack;
bcd4933a 4551#if !defined(TARGET_PPC64)
60e99246
AJ		 4552 int32_t tuc_pad[7];
4553 target_ulong tuc_regs; /* struct mcontext __user *
bcd4933a
NF		 4554 points to uc_mcontext field */
4555#endif
60e99246 4556 target_sigset_t tuc_sigmask;
bcd4933a 4557#if defined(TARGET_PPC64)
c227f099 4558 target_sigset_t unused[15]; /* Allow for uc_sigmask growth */
60e99246 4559 struct target_sigcontext tuc_mcontext;
bcd4933a 4560#else
60e99246
AJ		 4561 int32_t tuc_maskext[30];
4562 int32_t tuc_pad2[3];
4563 struct target_mcontext tuc_mcontext;
bcd4933a
NF		 4564#endif
4565};
4566
4567/* See arch/powerpc/kernel/signal_32.c. */
4568struct target_sigframe {
4569 struct target_sigcontext sctx;
4570 struct target_mcontext mctx;
4571 int32_t abigap[56];
4572};
4573
4574struct target_rt_sigframe {
4575 struct target_siginfo info;
4576 struct target_ucontext uc;
4577 int32_t abigap[56];
4578};
4579
4580/* We use the mc_pad field for the signal return trampoline. */
4581#define tramp mc_pad
4582
4583/* See arch/powerpc/kernel/signal.c. */
4584static target_ulong get_sigframe(struct target_sigaction *ka,
05390248 4585 CPUPPCState *env,
bcd4933a
NF		 4586 int frame_size)
4587{
4588 target_ulong oldsp, newsp;
4589
4590 oldsp = env->gpr[1];
4591
4592 if ((ka->sa_flags & TARGET_SA_ONSTACK) &&
32a2003a 4593 (sas_ss_flags(oldsp) == 0)) {
bcd4933a
NF		 4594 oldsp = (target_sigaltstack_used.ss_sp
4595 + target_sigaltstack_used.ss_size);
4596 }
4597
4598 newsp = (oldsp - frame_size) & ~0xFUL;
4599
4600 return newsp;
4601}
4602
05390248 4603static int save_user_regs(CPUPPCState *env, struct target_mcontext *frame,
bcd4933a
NF		 4604 int sigret)
4605{
4606 target_ulong msr = env->msr;
4607 int i;
4608 target_ulong ccr = 0;
4609
4610 /* In general, the kernel attempts to be intelligent about what it
4611 needs to save for Altivec/FP/SPE registers. We don't care that
4612 much, so we just go ahead and save everything. */
4613
4614 /* Save general registers. */
4615 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
4616 if (__put_user(env->gpr[i], &frame->mc_gregs[i])) {
4617 return 1;
4618 }
4619 }
4620 if (__put_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP])
4621 || __put_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR])
4622 || __put_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK])
4623 || __put_user(env->xer, &frame->mc_gregs[TARGET_PT_XER]))
4624 return 1;
4625
4626 for (i = 0; i < ARRAY_SIZE(env->crf); i++) {
4627 ccr |= env->crf[i] << (32 - ((i + 1) * 4));
4628 }
4629 if (__put_user(ccr, &frame->mc_gregs[TARGET_PT_CCR]))
4630 return 1;
4631
4632 /* Save Altivec registers if necessary. */
4633 if (env->insns_flags & PPC_ALTIVEC) {
4634 for (i = 0; i < ARRAY_SIZE(env->avr); i++) {
c227f099
AL		 4635 ppc_avr_t *avr = &env->avr[i];
4636 ppc_avr_t *vreg = &frame->mc_vregs.altivec[i];
bcd4933a
NF		 4637
4638 if (__put_user(avr->u64[0], &vreg->u64[0]) ||
4639 __put_user(avr->u64[1], &vreg->u64[1])) {
4640 return 1;
4641 }
4642 }
4643 /* Set MSR_VR in the saved MSR value to indicate that
4644 frame->mc_vregs contains valid data. */
4645 msr |= MSR_VR;
4646 if (__put_user((uint32_t)env->spr[SPR_VRSAVE],
4647 &frame->mc_vregs.altivec[32].u32[3]))
4648 return 1;
4649 }
4650
4651 /* Save floating point registers. */
4652 if (env->insns_flags & PPC_FLOAT) {
4653 for (i = 0; i < ARRAY_SIZE(env->fpr); i++) {
4654 if (__put_user(env->fpr[i], &frame->mc_fregs[i])) {
4655 return 1;
4656 }
4657 }
4658 if (__put_user((uint64_t) env->fpscr, &frame->mc_fregs[32]))
4659 return 1;
4660 }
4661
4662 /* Save SPE registers. The kernel only saves the high half. */
4663 if (env->insns_flags & PPC_SPE) {
4664#if defined(TARGET_PPC64)
4665 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
4666 if (__put_user(env->gpr[i] >> 32, &frame->mc_vregs.spe[i])) {
4667 return 1;
4668 }
4669 }
4670#else
4671 for (i = 0; i < ARRAY_SIZE(env->gprh); i++) {
4672 if (__put_user(env->gprh[i], &frame->mc_vregs.spe[i])) {
4673 return 1;
4674 }
4675 }
4676#endif
4677 /* Set MSR_SPE in the saved MSR value to indicate that
4678 frame->mc_vregs contains valid data. */
4679 msr |= MSR_SPE;
4680 if (__put_user(env->spe_fscr, &frame->mc_vregs.spe[32]))
4681 return 1;
4682 }
4683
4684 /* Store MSR. */
4685 if (__put_user(msr, &frame->mc_gregs[TARGET_PT_MSR]))
4686 return 1;
4687
4688 /* Set up the sigreturn trampoline: li r0,sigret; sc. */
4689 if (sigret) {
4690 if (__put_user(0x38000000UL | sigret, &frame->tramp[0]) ||
4691 __put_user(0x44000002UL, &frame->tramp[1])) {
4692 return 1;
4693 }
4694 }
4695
4696 return 0;
4697}
4698
05390248 4699static int restore_user_regs(CPUPPCState *env,
bcd4933a
NF		 4700 struct target_mcontext *frame, int sig)
4701{
4702 target_ulong save_r2 = 0;
4703 target_ulong msr;
4704 target_ulong ccr;
4705
4706 int i;
4707
4708 if (!sig) {
4709 save_r2 = env->gpr[2];
4710 }
4711
4712 /* Restore general registers. */
4713 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
4714 if (__get_user(env->gpr[i], &frame->mc_gregs[i])) {
4715 return 1;
4716 }
4717 }
4718 if (__get_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP])
4719 || __get_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR])
4720 || __get_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK])
4721 || __get_user(env->xer, &frame->mc_gregs[TARGET_PT_XER]))
4722 return 1;
4723 if (__get_user(ccr, &frame->mc_gregs[TARGET_PT_CCR]))
4724 return 1;
4725
4726 for (i = 0; i < ARRAY_SIZE(env->crf); i++) {
4727 env->crf[i] = (ccr >> (32 - ((i + 1) * 4))) & 0xf;
4728 }
4729
4730 if (!sig) {
4731 env->gpr[2] = save_r2;
4732 }
4733 /* Restore MSR. */
4734 if (__get_user(msr, &frame->mc_gregs[TARGET_PT_MSR]))
4735 return 1;
4736
4737 /* If doing signal return, restore the previous little-endian mode. */
4738 if (sig)
4739 env->msr = (env->msr & ~MSR_LE) | (msr & MSR_LE);
4740
4741 /* Restore Altivec registers if necessary. */
4742 if (env->insns_flags & PPC_ALTIVEC) {
4743 for (i = 0; i < ARRAY_SIZE(env->avr); i++) {
c227f099
AL		 4744 ppc_avr_t *avr = &env->avr[i];
4745 ppc_avr_t *vreg = &frame->mc_vregs.altivec[i];
bcd4933a
NF		 4746
4747 if (__get_user(avr->u64[0], &vreg->u64[0]) ||
4748 __get_user(avr->u64[1], &vreg->u64[1])) {
4749 return 1;
4750 }
4751 }
4752 /* Set MSR_VEC in the saved MSR value to indicate that
4753 frame->mc_vregs contains valid data. */
4754 if (__get_user(env->spr[SPR_VRSAVE],
4755 (target_ulong *)(&frame->mc_vregs.altivec[32].u32[3])))
4756 return 1;
4757 }
4758
4759 /* Restore floating point registers. */
4760 if (env->insns_flags & PPC_FLOAT) {
4761 uint64_t fpscr;
4762 for (i = 0; i < ARRAY_SIZE(env->fpr); i++) {
4763 if (__get_user(env->fpr[i], &frame->mc_fregs[i])) {
4764 return 1;
4765 }
4766 }
4767 if (__get_user(fpscr, &frame->mc_fregs[32]))
4768 return 1;
4769 env->fpscr = (uint32_t) fpscr;
4770 }
4771
4772 /* Save SPE registers. The kernel only saves the high half. */
4773 if (env->insns_flags & PPC_SPE) {
4774#if defined(TARGET_PPC64)
4775 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
4776 uint32_t hi;
4777
4778 if (__get_user(hi, &frame->mc_vregs.spe[i])) {
4779 return 1;
4780 }
4781 env->gpr[i] = ((uint64_t)hi << 32) | ((uint32_t) env->gpr[i]);
4782 }
4783#else
4784 for (i = 0; i < ARRAY_SIZE(env->gprh); i++) {
4785 if (__get_user(env->gprh[i], &frame->mc_vregs.spe[i])) {
4786 return 1;
4787 }
4788 }
4789#endif
4790 if (__get_user(env->spe_fscr, &frame->mc_vregs.spe[32]))
4791 return 1;
4792 }
4793
4794 return 0;
4795}
4796
4797static void setup_frame(int sig, struct target_sigaction *ka,
05390248 4798 target_sigset_t *set, CPUPPCState *env)
bcd4933a
NF		 4799{
4800 struct target_sigframe *frame;
4801 struct target_sigcontext *sc;
4802 target_ulong frame_addr, newsp;
4803 int err = 0;
4804 int signal;
4805
4806 frame_addr = get_sigframe(ka, env, sizeof(*frame));
4807 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
4808 goto sigsegv;
4809 sc = &frame->sctx;
4810
4811 signal = current_exec_domain_sig(sig);
4812
1d8b512b
RV		 4813 __put_user(ka->_sa_handler, &sc->handler);
4814 __put_user(set->sig[0], &sc->oldmask);
bcd4933a 4815#if defined(TARGET_PPC64)
1d8b512b 4816 __put_user(set->sig[0] >> 32, &sc->_unused[3]);
bcd4933a 4817#else
1d8b512b 4818 __put_user(set->sig[1], &sc->_unused[3]);
bcd4933a 4819#endif
1d8b512b
RV		 4820 __put_user(h2g(&frame->mctx), &sc->regs);
4821 __put_user(sig, &sc->signal);
bcd4933a
NF		 4822
4823 /* Save user regs. */
4824 err |= save_user_regs(env, &frame->mctx, TARGET_NR_sigreturn);
4825
4826 /* The kernel checks for the presence of a VDSO here. We don't
4827 emulate a vdso, so use a sigreturn system call. */
4828 env->lr = (target_ulong) h2g(frame->mctx.tramp);
4829
4830 /* Turn off all fp exceptions. */
4831 env->fpscr = 0;
4832
4833 /* Create a stack frame for the caller of the handler. */
4834 newsp = frame_addr - SIGNAL_FRAMESIZE;
beb526b1 4835 err |= put_user(env->gpr[1], newsp, target_ulong);
bcd4933a
NF		 4836
4837 if (err)
4838 goto sigsegv;
4839
4840 /* Set up registers for signal handler. */
4841 env->gpr[1] = newsp;
4842 env->gpr[3] = signal;
61993a67 4843 env->gpr[4] = frame_addr + offsetof(struct target_sigframe, sctx);
bcd4933a
NF		 4844 env->nip = (target_ulong) ka->_sa_handler;
4845 /* Signal handlers are entered in big-endian mode. */
4846 env->msr &= ~MSR_LE;
4847
4848 unlock_user_struct(frame, frame_addr, 1);
4849 return;
4850
4851sigsegv:
4852 unlock_user_struct(frame, frame_addr, 1);
eeacee4d 4853 qemu_log("segfaulting from setup_frame\n");
66393fb9 4854 force_sig(TARGET_SIGSEGV);
bcd4933a
NF		 4855}
4856
4857static void setup_rt_frame(int sig, struct target_sigaction *ka,
c227f099 4858 target_siginfo_t *info,
05390248 4859 target_sigset_t *set, CPUPPCState *env)
bcd4933a
NF		 4860{
4861 struct target_rt_sigframe *rt_sf;
4862 struct target_mcontext *frame;
4863 target_ulong rt_sf_addr, newsp = 0;
4864 int i, err = 0;
4865 int signal;
4866
4867 rt_sf_addr = get_sigframe(ka, env, sizeof(*rt_sf));
4868 if (!lock_user_struct(VERIFY_WRITE, rt_sf, rt_sf_addr, 1))
4869 goto sigsegv;
4870
4871 signal = current_exec_domain_sig(sig);
4872
b0fd8d18 4873 copy_siginfo_to_user(&rt_sf->info, info);
bcd4933a 4874
1d8b512b
RV		 4875 __put_user(0, &rt_sf->uc.tuc_flags);
4876 __put_user(0, &rt_sf->uc.tuc_link);
4877 __put_user((target_ulong)target_sigaltstack_used.ss_sp,
4878 &rt_sf->uc.tuc_stack.ss_sp);
4879 __put_user(sas_ss_flags(env->gpr[1]),
4880 &rt_sf->uc.tuc_stack.ss_flags);
4881 __put_user(target_sigaltstack_used.ss_size,
4882 &rt_sf->uc.tuc_stack.ss_size);
4883 __put_user(h2g (&rt_sf->uc.tuc_mcontext),
4884 &rt_sf->uc.tuc_regs);
bcd4933a 4885 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1d8b512b 4886 __put_user(set->sig[i], &rt_sf->uc.tuc_sigmask.sig[i]);
bcd4933a
NF		 4887 }
4888
60e99246 4889 frame = &rt_sf->uc.tuc_mcontext;
bcd4933a
NF		 4890 err |= save_user_regs(env, frame, TARGET_NR_rt_sigreturn);
4891
4892 /* The kernel checks for the presence of a VDSO here. We don't
4893 emulate a vdso, so use a sigreturn system call. */
4894 env->lr = (target_ulong) h2g(frame->tramp);
4895
4896 /* Turn off all fp exceptions. */
4897 env->fpscr = 0;
4898
4899 /* Create a stack frame for the caller of the handler. */
4900 newsp = rt_sf_addr - (SIGNAL_FRAMESIZE + 16);
1d8b512b 4901 __put_user(env->gpr[1], (target_ulong *)(uintptr_t) newsp);
bcd4933a
NF		 4902
4903 if (err)
4904 goto sigsegv;
4905
4906 /* Set up registers for signal handler. */
4907 env->gpr[1] = newsp;
4908 env->gpr[3] = (target_ulong) signal;
4909 env->gpr[4] = (target_ulong) h2g(&rt_sf->info);
4910 env->gpr[5] = (target_ulong) h2g(&rt_sf->uc);
4911 env->gpr[6] = (target_ulong) h2g(rt_sf);
4912 env->nip = (target_ulong) ka->_sa_handler;
4913 /* Signal handlers are entered in big-endian mode. */
4914 env->msr &= ~MSR_LE;
4915
4916 unlock_user_struct(rt_sf, rt_sf_addr, 1);
4917 return;
4918
4919sigsegv:
4920 unlock_user_struct(rt_sf, rt_sf_addr, 1);
eeacee4d 4921 qemu_log("segfaulting from setup_rt_frame\n");
66393fb9 4922 force_sig(TARGET_SIGSEGV);
bcd4933a
NF		 4923
4924}
4925
05390248 4926long do_sigreturn(CPUPPCState *env)
bcd4933a
NF		 4927{
4928 struct target_sigcontext *sc = NULL;
4929 struct target_mcontext *sr = NULL;
b04636f8 4930 target_ulong sr_addr = 0, sc_addr;
bcd4933a 4931 sigset_t blocked;
c227f099 4932 target_sigset_t set;
bcd4933a
NF		 4933
4934 sc_addr = env->gpr[1] + SIGNAL_FRAMESIZE;
4935 if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1))
4936 goto sigsegv;
4937
4938#if defined(TARGET_PPC64)
4939 set.sig[0] = sc->oldmask + ((long)(sc->_unused[3]) << 32);
4940#else
4941 if(__get_user(set.sig[0], &sc->oldmask) ||
4942 __get_user(set.sig[1], &sc->_unused[3]))
4943 goto sigsegv;
4944#endif
4945 target_to_host_sigset_internal(&blocked, &set);
1c275925 4946 do_sigprocmask(SIG_SETMASK, &blocked, NULL);
bcd4933a
NF		 4947
4948 if (__get_user(sr_addr, &sc->regs))
4949 goto sigsegv;
4950 if (!lock_user_struct(VERIFY_READ, sr, sr_addr, 1))
4951 goto sigsegv;
4952 if (restore_user_regs(env, sr, 1))
4953 goto sigsegv;
4954
4955 unlock_user_struct(sr, sr_addr, 1);
4956 unlock_user_struct(sc, sc_addr, 1);
4957 return -TARGET_QEMU_ESIGRETURN;
4958
4959sigsegv:
4960 unlock_user_struct(sr, sr_addr, 1);
4961 unlock_user_struct(sc, sc_addr, 1);
eeacee4d 4962 qemu_log("segfaulting from do_sigreturn\n");
66393fb9 4963 force_sig(TARGET_SIGSEGV);
bcd4933a
NF		 4964 return 0;
4965}
4966
4967/* See arch/powerpc/kernel/signal_32.c. */
05390248 4968static int do_setcontext(struct target_ucontext *ucp, CPUPPCState *env, int sig)
bcd4933a
NF		 4969{
4970 struct target_mcontext *mcp;
4971 target_ulong mcp_addr;
4972 sigset_t blocked;
c227f099 4973 target_sigset_t set;
bcd4933a 4974
60e99246 4975 if (copy_from_user(&set, h2g(ucp) + offsetof(struct target_ucontext, tuc_sigmask),
bcd4933a
NF		 4976 sizeof (set)))
4977 return 1;
4978
4979#if defined(TARGET_PPC64)
4980 fprintf (stderr, "do_setcontext: not implemented\n");
4981 return 0;
4982#else
60e99246 4983 if (__get_user(mcp_addr, &ucp->tuc_regs))
bcd4933a
NF		 4984 return 1;
4985
4986 if (!lock_user_struct(VERIFY_READ, mcp, mcp_addr, 1))
4987 return 1;
4988
4989 target_to_host_sigset_internal(&blocked, &set);
1c275925 4990 do_sigprocmask(SIG_SETMASK, &blocked, NULL);
bcd4933a
NF		 4991 if (restore_user_regs(env, mcp, sig))
4992 goto sigsegv;
4993
4994 unlock_user_struct(mcp, mcp_addr, 1);
4995 return 0;
4996
4997sigsegv:
4998 unlock_user_struct(mcp, mcp_addr, 1);
4999 return 1;
5000#endif
5001}
5002
05390248 5003long do_rt_sigreturn(CPUPPCState *env)
bcd4933a
NF		 5004{
5005 struct target_rt_sigframe *rt_sf = NULL;
5006 target_ulong rt_sf_addr;
5007
5008 rt_sf_addr = env->gpr[1] + SIGNAL_FRAMESIZE + 16;
5009 if (!lock_user_struct(VERIFY_READ, rt_sf, rt_sf_addr, 1))
5010 goto sigsegv;
5011
5012 if (do_setcontext(&rt_sf->uc, env, 1))
5013 goto sigsegv;
5014
5015 do_sigaltstack(rt_sf_addr
60e99246 5016 + offsetof(struct target_rt_sigframe, uc.tuc_stack),
bcd4933a
NF		 5017 0, env->gpr[1]);
5018
5019 unlock_user_struct(rt_sf, rt_sf_addr, 1);
5020 return -TARGET_QEMU_ESIGRETURN;
5021
5022sigsegv:
5023 unlock_user_struct(rt_sf, rt_sf_addr, 1);
eeacee4d 5024 qemu_log("segfaulting from do_rt_sigreturn\n");
66393fb9 5025 force_sig(TARGET_SIGSEGV);
bcd4933a
NF		 5026 return 0;
5027}
5028
492a8744
LV		 5029#elif defined(TARGET_M68K)
5030
5031struct target_sigcontext {
5032 abi_ulong sc_mask;
5033 abi_ulong sc_usp;
5034 abi_ulong sc_d0;
5035 abi_ulong sc_d1;
5036 abi_ulong sc_a0;
5037 abi_ulong sc_a1;
5038 unsigned short sc_sr;
5039 abi_ulong sc_pc;
5040};
5041
5042struct target_sigframe
5043{
5044 abi_ulong pretcode;
5045 int sig;
5046 int code;
5047 abi_ulong psc;
5048 char retcode[8];
5049 abi_ulong extramask[TARGET_NSIG_WORDS-1];
5050 struct target_sigcontext sc;
5051};
7181155d 5052
c227f099 5053typedef int target_greg_t;
7181155d 5054#define TARGET_NGREG 18
c227f099 5055typedef target_greg_t target_gregset_t[TARGET_NGREG];
7181155d
LV		 5056
5057typedef struct target_fpregset {
5058 int f_fpcntl[3];
5059 int f_fpregs[8*3];
c227f099 5060} target_fpregset_t;
7181155d
LV		 5061
5062struct target_mcontext {
5063 int version;
c227f099
AL		 5064 target_gregset_t gregs;
5065 target_fpregset_t fpregs;
7181155d
LV		 5066};
5067
5068#define TARGET_MCONTEXT_VERSION 2
5069
5070struct target_ucontext {
60e99246
AJ		 5071 abi_ulong tuc_flags;
5072 abi_ulong tuc_link;
5073 target_stack_t tuc_stack;
5074 struct target_mcontext tuc_mcontext;
5075 abi_long tuc_filler[80];
5076 target_sigset_t tuc_sigmask;
7181155d
LV		 5077};
5078
5079struct target_rt_sigframe
5080{
5081 abi_ulong pretcode;
5082 int sig;
5083 abi_ulong pinfo;
5084 abi_ulong puc;
5085 char retcode[8];
5086 struct target_siginfo info;
5087 struct target_ucontext uc;
5088};
492a8744
LV		 5089
5090static int
05390248
AF		 5091setup_sigcontext(struct target_sigcontext *sc, CPUM68KState *env,
5092 abi_ulong mask)
492a8744
LV		 5093{
5094 int err = 0;
5095
1d8b512b
RV		 5096 __put_user(mask, &sc->sc_mask);
5097 __put_user(env->aregs[7], &sc->sc_usp);
5098 __put_user(env->dregs[0], &sc->sc_d0);
5099 __put_user(env->dregs[1], &sc->sc_d1);
5100 __put_user(env->aregs[0], &sc->sc_a0);
5101 __put_user(env->aregs[1], &sc->sc_a1);
5102 __put_user(env->sr, &sc->sc_sr);
5103 __put_user(env->pc, &sc->sc_pc);
492a8744
LV		 5104
5105 return err;
5106}
5107
5108static int
05390248 5109restore_sigcontext(CPUM68KState *env, struct target_sigcontext *sc, int *pd0)
492a8744
LV		 5110{
5111 int err = 0;
5112 int temp;
5113
1d8b512b
RV		 5114 __get_user(env->aregs[7], &sc->sc_usp);
5115 __get_user(env->dregs[1], &sc->sc_d1);
5116 __get_user(env->aregs[0], &sc->sc_a0);
5117 __get_user(env->aregs[1], &sc->sc_a1);
5118 __get_user(env->pc, &sc->sc_pc);
5119 __get_user(temp, &sc->sc_sr);
492a8744
LV		 5120 env->sr = (env->sr & 0xff00) | (temp & 0xff);
5121
5122 *pd0 = tswapl(sc->sc_d0);
5123
5124 return err;
5125}
5126
5127/*
5128 * Determine which stack to use..
5129 */
5130static inline abi_ulong
05390248
AF		 5131get_sigframe(struct target_sigaction *ka, CPUM68KState *regs,
5132 size_t frame_size)
492a8744
LV		 5133{
5134 unsigned long sp;
5135
5136 sp = regs->aregs[7];
5137
5138 /* This is the X/Open sanctioned signal stack switching. */
5139 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) {
5140 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
5141 }
5142
5143 return ((sp - frame_size) & -8UL);
5144}
5145
5146static void setup_frame(int sig, struct target_sigaction *ka,
05390248 5147 target_sigset_t *set, CPUM68KState *env)
492a8744
LV		 5148{
5149 struct target_sigframe *frame;
5150 abi_ulong frame_addr;
5151 abi_ulong retcode_addr;
5152 abi_ulong sc_addr;
5153 int err = 0;
5154 int i;
5155
5156 frame_addr = get_sigframe(ka, env, sizeof *frame);
5157 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
5158 goto give_sigsegv;
5159
1d8b512b 5160 __put_user(sig, &frame->sig);
492a8744
LV		 5161
5162 sc_addr = frame_addr + offsetof(struct target_sigframe, sc);
1d8b512b 5163 __put_user(sc_addr, &frame->psc);
492a8744
LV		 5164
5165 err |= setup_sigcontext(&frame->sc, env, set->sig[0]);
5166 if (err)
5167 goto give_sigsegv;
5168
5169 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
5170 if (__put_user(set->sig[i], &frame->extramask[i - 1]))
5171 goto give_sigsegv;
5172 }
5173
5174 /* Set up to return from userspace. */
5175
5176 retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode);
1d8b512b 5177 __put_user(retcode_addr, &frame->pretcode);
492a8744
LV		 5178
5179 /* moveq #,d0; trap #0 */
5180
1d8b512b 5181 __put_user(0x70004e40 + (TARGET_NR_sigreturn << 16),
492a8744
LV		 5182 (long *)(frame->retcode));
5183
5184 if (err)
5185 goto give_sigsegv;
5186
5187 /* Set up to return from userspace */
5188
5189 env->aregs[7] = frame_addr;
5190 env->pc = ka->_sa_handler;
5191
5192 unlock_user_struct(frame, frame_addr, 1);
5193 return;
5194
5195give_sigsegv:
5196 unlock_user_struct(frame, frame_addr, 1);
66393fb9 5197 force_sig(TARGET_SIGSEGV);
492a8744
LV		 5198}
5199
7181155d 5200static inline int target_rt_setup_ucontext(struct target_ucontext *uc,
05390248 5201 CPUM68KState *env)
7181155d 5202{
60e99246 5203 target_greg_t *gregs = uc->tuc_mcontext.gregs;
7181155d 5204
1d8b512b
RV		 5205 __put_user(TARGET_MCONTEXT_VERSION, &uc->tuc_mcontext.version);
5206 __put_user(env->dregs[0], &gregs[0]);
5207 __put_user(env->dregs[1], &gregs[1]);
5208 __put_user(env->dregs[2], &gregs[2]);
5209 __put_user(env->dregs[3], &gregs[3]);
5210 __put_user(env->dregs[4], &gregs[4]);
5211 __put_user(env->dregs[5], &gregs[5]);
5212 __put_user(env->dregs[6], &gregs[6]);
5213 __put_user(env->dregs[7], &gregs[7]);
5214 __put_user(env->aregs[0], &gregs[8]);
5215 __put_user(env->aregs[1], &gregs[9]);
5216 __put_user(env->aregs[2], &gregs[10]);
5217 __put_user(env->aregs[3], &gregs[11]);
5218 __put_user(env->aregs[4], &gregs[12]);
5219 __put_user(env->aregs[5], &gregs[13]);
5220 __put_user(env->aregs[6], &gregs[14]);
5221 __put_user(env->aregs[7], &gregs[15]);
5222 __put_user(env->pc, &gregs[16]);
5223 __put_user(env->sr, &gregs[17]);
7181155d 5224
1d8b512b 5225 return 0;
7181155d
LV		 5226}
5227
05390248 5228static inline int target_rt_restore_ucontext(CPUM68KState *env,
7181155d
LV		 5229 struct target_ucontext *uc,
5230 int *pd0)
5231{
5232 int temp;
60e99246 5233 target_greg_t *gregs = uc->tuc_mcontext.gregs;
7181155d 5234
1d8b512b 5235 __get_user(temp, &uc->tuc_mcontext.version);
7181155d
LV		 5236 if (temp != TARGET_MCONTEXT_VERSION)
5237 goto badframe;
5238
5239 /* restore passed registers */
1d8b512b
RV		 5240 __get_user(env->dregs[0], &gregs[0]);
5241 __get_user(env->dregs[1], &gregs[1]);
5242 __get_user(env->dregs[2], &gregs[2]);
5243 __get_user(env->dregs[3], &gregs[3]);
5244 __get_user(env->dregs[4], &gregs[4]);
5245 __get_user(env->dregs[5], &gregs[5]);
5246 __get_user(env->dregs[6], &gregs[6]);
5247 __get_user(env->dregs[7], &gregs[7]);
5248 __get_user(env->aregs[0], &gregs[8]);
5249 __get_user(env->aregs[1], &gregs[9]);
5250 __get_user(env->aregs[2], &gregs[10]);
5251 __get_user(env->aregs[3], &gregs[11]);
5252 __get_user(env->aregs[4], &gregs[12]);
5253 __get_user(env->aregs[5], &gregs[13]);
5254 __get_user(env->aregs[6], &gregs[14]);
5255 __get_user(env->aregs[7], &gregs[15]);
5256 __get_user(env->pc, &gregs[16]);
5257 __get_user(temp, &gregs[17]);
7181155d
LV		 5258 env->sr = (env->sr & 0xff00) | (temp & 0xff);
5259
5260 *pd0 = env->dregs[0];
1d8b512b 5261 return 0;
7181155d
LV		 5262
5263badframe:
5264 return 1;
5265}
5266
492a8744 5267static void setup_rt_frame(int sig, struct target_sigaction *ka,
c227f099 5268 target_siginfo_t *info,
05390248 5269 target_sigset_t *set, CPUM68KState *env)
492a8744 5270{
7181155d
LV		 5271 struct target_rt_sigframe *frame;
5272 abi_ulong frame_addr;
5273 abi_ulong retcode_addr;
5274 abi_ulong info_addr;
5275 abi_ulong uc_addr;
5276 int err = 0;
5277 int i;
5278
5279 frame_addr = get_sigframe(ka, env, sizeof *frame);
5280 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
5281 goto give_sigsegv;
5282
1d8b512b 5283 __put_user(sig, &frame->sig);
7181155d
LV		 5284
5285 info_addr = frame_addr + offsetof(struct target_rt_sigframe, info);
1d8b512b 5286 __put_user(info_addr, &frame->pinfo);
7181155d
LV		 5287
5288 uc_addr = frame_addr + offsetof(struct target_rt_sigframe, uc);
1d8b512b 5289 __put_user(uc_addr, &frame->puc);
7181155d 5290
b0fd8d18 5291 copy_siginfo_to_user(&frame->info, info);
7181155d
LV		 5292
5293 /* Create the ucontext */
5294
1d8b512b
RV		 5295 __put_user(0, &frame->uc.tuc_flags);
5296 __put_user(0, &frame->uc.tuc_link);
5297 __put_user(target_sigaltstack_used.ss_sp,
5298 &frame->uc.tuc_stack.ss_sp);
5299 __put_user(sas_ss_flags(env->aregs[7]),
5300 &frame->uc.tuc_stack.ss_flags);
5301 __put_user(target_sigaltstack_used.ss_size,
5302 &frame->uc.tuc_stack.ss_size);
7181155d
LV		 5303 err |= target_rt_setup_ucontext(&frame->uc, env);
5304
5305 if (err)
5306 goto give_sigsegv;
5307
5308 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
60e99246 5309 if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
7181155d
LV		 5310 goto give_sigsegv;
5311 }
5312
5313 /* Set up to return from userspace. */
5314
5315 retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode);
1d8b512b 5316 __put_user(retcode_addr, &frame->pretcode);
7181155d
LV		 5317
5318 /* moveq #,d0; notb d0; trap #0 */
5319
1d8b512b
RV		 5320 __put_user(0x70004600 + ((TARGET_NR_rt_sigreturn ^ 0xff) << 16),
5321 (long *)(frame->retcode + 0));
5322 __put_user(0x4e40, (short *)(frame->retcode + 4));
7181155d
LV		 5323
5324 if (err)
5325 goto give_sigsegv;
5326
5327 /* Set up to return from userspace */
5328
5329 env->aregs[7] = frame_addr;
5330 env->pc = ka->_sa_handler;
5331
5332 unlock_user_struct(frame, frame_addr, 1);
5333 return;
5334
5335give_sigsegv:
5336 unlock_user_struct(frame, frame_addr, 1);
66393fb9 5337 force_sig(TARGET_SIGSEGV);
492a8744
LV		 5338}
5339
05390248 5340long do_sigreturn(CPUM68KState *env)
492a8744
LV		 5341{
5342 struct target_sigframe *frame;
5343 abi_ulong frame_addr = env->aregs[7] - 4;
c227f099 5344 target_sigset_t target_set;
492a8744
LV		 5345 sigset_t set;
5346 int d0, i;
5347
5348 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
5349 goto badframe;
5350
5351 /* set blocked signals */
5352
5353 if (__get_user(target_set.sig[0], &frame->sc.sc_mask))
5354 goto badframe;
5355
5356 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
5357 if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
5358 goto badframe;
5359 }
5360
5361 target_to_host_sigset_internal(&set, &target_set);
1c275925 5362 do_sigprocmask(SIG_SETMASK, &set, NULL);
492a8744
LV		 5363
5364 /* restore registers */
5365
5366 if (restore_sigcontext(env, &frame->sc, &d0))
5367 goto badframe;
5368
5369 unlock_user_struct(frame, frame_addr, 0);
5370 return d0;
5371
5372badframe:
5373 unlock_user_struct(frame, frame_addr, 0);
5374 force_sig(TARGET_SIGSEGV);
5375 return 0;
5376}
5377
05390248 5378long do_rt_sigreturn(CPUM68KState *env)
492a8744 5379{
7181155d
LV		 5380 struct target_rt_sigframe *frame;
5381 abi_ulong frame_addr = env->aregs[7] - 4;
c227f099 5382 target_sigset_t target_set;
7181155d
LV		 5383 sigset_t set;
5384 int d0;
5385
5386 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
5387 goto badframe;
5388
5389 target_to_host_sigset_internal(&set, &target_set);
1c275925 5390 do_sigprocmask(SIG_SETMASK, &set, NULL);
7181155d
LV		 5391
5392 /* restore registers */
5393
5394 if (target_rt_restore_ucontext(env, &frame->uc, &d0))
5395 goto badframe;
5396
5397 if (do_sigaltstack(frame_addr +
60e99246 5398 offsetof(struct target_rt_sigframe, uc.tuc_stack),
7181155d
LV		 5399 0, get_sp_from_cpustate(env)) == -EFAULT)
5400 goto badframe;
5401
5402 unlock_user_struct(frame, frame_addr, 0);
5403 return d0;
5404
5405badframe:
5406 unlock_user_struct(frame, frame_addr, 0);
5407 force_sig(TARGET_SIGSEGV);
5408 return 0;
492a8744
LV		 5409}
5410
6049f4f8
RH		 5411#elif defined(TARGET_ALPHA)
5412
5413struct target_sigcontext {
5414 abi_long sc_onstack;
5415 abi_long sc_mask;
5416 abi_long sc_pc;
5417 abi_long sc_ps;
5418 abi_long sc_regs[32];
5419 abi_long sc_ownedfp;
5420 abi_long sc_fpregs[32];
5421 abi_ulong sc_fpcr;
5422 abi_ulong sc_fp_control;
5423 abi_ulong sc_reserved1;
5424 abi_ulong sc_reserved2;
5425 abi_ulong sc_ssize;
5426 abi_ulong sc_sbase;
5427 abi_ulong sc_traparg_a0;
5428 abi_ulong sc_traparg_a1;
5429 abi_ulong sc_traparg_a2;
5430 abi_ulong sc_fp_trap_pc;
5431 abi_ulong sc_fp_trigger_sum;
5432 abi_ulong sc_fp_trigger_inst;
5433};
5434
5435struct target_ucontext {
60e99246
AJ		 5436 abi_ulong tuc_flags;
5437 abi_ulong tuc_link;
5438 abi_ulong tuc_osf_sigmask;
5439 target_stack_t tuc_stack;
5440 struct target_sigcontext tuc_mcontext;
5441 target_sigset_t tuc_sigmask;
6049f4f8
RH		 5442};
5443
5444struct target_sigframe {
5445 struct target_sigcontext sc;
5446 unsigned int retcode[3];
5447};
5448
5449struct target_rt_sigframe {
5450 target_siginfo_t info;
5451 struct target_ucontext uc;
5452 unsigned int retcode[3];
5453};
5454
5455#define INSN_MOV_R30_R16 0x47fe0410
5456#define INSN_LDI_R0 0x201f0000
5457#define INSN_CALLSYS 0x00000083
5458
05390248 5459static int setup_sigcontext(struct target_sigcontext *sc, CPUAlphaState *env,
6049f4f8
RH		 5460 abi_ulong frame_addr, target_sigset_t *set)
5461{
5462 int i, err = 0;
5463
1d8b512b
RV		 5464 __put_user(on_sig_stack(frame_addr), &sc->sc_onstack);
5465 __put_user(set->sig[0], &sc->sc_mask);
5466 __put_user(env->pc, &sc->sc_pc);
5467 __put_user(8, &sc->sc_ps);
6049f4f8
RH		 5468
5469 for (i = 0; i < 31; ++i) {
1d8b512b 5470 __put_user(env->ir[i], &sc->sc_regs[i]);
6049f4f8 5471 }
1d8b512b 5472 __put_user(0, &sc->sc_regs[31]);
6049f4f8
RH		 5473
5474 for (i = 0; i < 31; ++i) {
1d8b512b 5475 __put_user(env->fir[i], &sc->sc_fpregs[i]);
6049f4f8 5476 }
1d8b512b
RV		 5477 __put_user(0, &sc->sc_fpregs[31]);
5478 __put_user(cpu_alpha_load_fpcr(env), &sc->sc_fpcr);
6049f4f8 5479
1d8b512b
RV		 5480 __put_user(0, &sc->sc_traparg_a0); /* FIXME */
5481 __put_user(0, &sc->sc_traparg_a1); /* FIXME */
5482 __put_user(0, &sc->sc_traparg_a2); /* FIXME */
6049f4f8
RH		 5483
5484 return err;
5485}
5486
05390248
AF		 5487static int restore_sigcontext(CPUAlphaState *env,
5488 struct target_sigcontext *sc)
6049f4f8
RH		 5489{
5490 uint64_t fpcr;
5491 int i, err = 0;
5492
1d8b512b 5493 __get_user(env->pc, &sc->sc_pc);
6049f4f8
RH		 5494
5495 for (i = 0; i < 31; ++i) {
1d8b512b 5496 __get_user(env->ir[i], &sc->sc_regs[i]);
6049f4f8
RH		 5497 }
5498 for (i = 0; i < 31; ++i) {
1d8b512b 5499 __get_user(env->fir[i], &sc->sc_fpregs[i]);
6049f4f8
RH		 5500 }
5501
1d8b512b 5502 __get_user(fpcr, &sc->sc_fpcr);
6049f4f8
RH		 5503 cpu_alpha_store_fpcr(env, fpcr);
5504
5505 return err;
5506}
5507
5508static inline abi_ulong get_sigframe(struct target_sigaction *sa,
05390248
AF		 5509 CPUAlphaState *env,
5510 unsigned long framesize)
6049f4f8
RH		 5511{
5512 abi_ulong sp = env->ir[IR_SP];
5513
5514 /* This is the X/Open sanctioned signal stack switching. */
5515 if ((sa->sa_flags & TARGET_SA_ONSTACK) != 0 && !sas_ss_flags(sp)) {
5516 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
5517 }
5518 return (sp - framesize) & -32;
5519}
5520
5521static void setup_frame(int sig, struct target_sigaction *ka,
05390248 5522 target_sigset_t *set, CPUAlphaState *env)
6049f4f8
RH		 5523{
5524 abi_ulong frame_addr, r26;
5525 struct target_sigframe *frame;
5526 int err = 0;
5527
5528 frame_addr = get_sigframe(ka, env, sizeof(*frame));
5529 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
5530 goto give_sigsegv;
5531 }
5532
5533 err |= setup_sigcontext(&frame->sc, env, frame_addr, set);
5534
5535 if (ka->sa_restorer) {
5536 r26 = ka->sa_restorer;
5537 } else {
1d8b512b
RV		 5538 __put_user(INSN_MOV_R30_R16, &frame->retcode[0]);
5539 __put_user(INSN_LDI_R0 + TARGET_NR_sigreturn,
5540 &frame->retcode[1]);
5541 __put_user(INSN_CALLSYS, &frame->retcode[2]);
6049f4f8
RH		 5542 /* imb() */
5543 r26 = frame_addr;
5544 }
5545
5546 unlock_user_struct(frame, frame_addr, 1);
5547
5548 if (err) {
5549 give_sigsegv:
5550 if (sig == TARGET_SIGSEGV) {
5551 ka->_sa_handler = TARGET_SIG_DFL;
5552 }
5553 force_sig(TARGET_SIGSEGV);
5554 }
5555
5556 env->ir[IR_RA] = r26;
5557 env->ir[IR_PV] = env->pc = ka->_sa_handler;
5558 env->ir[IR_A0] = sig;
5559 env->ir[IR_A1] = 0;
5560 env->ir[IR_A2] = frame_addr + offsetof(struct target_sigframe, sc);
5561 env->ir[IR_SP] = frame_addr;
5562}
5563
5564static void setup_rt_frame(int sig, struct target_sigaction *ka,
5565 target_siginfo_t *info,
05390248 5566 target_sigset_t *set, CPUAlphaState *env)
6049f4f8
RH		 5567{
5568 abi_ulong frame_addr, r26;
5569 struct target_rt_sigframe *frame;
5570 int i, err = 0;
5571
5572 frame_addr = get_sigframe(ka, env, sizeof(*frame));
5573 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
5574 goto give_sigsegv;
5575 }
5576
b0fd8d18 5577 copy_siginfo_to_user(&frame->info, info);
6049f4f8 5578
1d8b512b
RV		 5579 __put_user(0, &frame->uc.tuc_flags);
5580 __put_user(0, &frame->uc.tuc_link);
5581 __put_user(set->sig[0], &frame->uc.tuc_osf_sigmask);
5582 __put_user(target_sigaltstack_used.ss_sp,
5583 &frame->uc.tuc_stack.ss_sp);
5584 __put_user(sas_ss_flags(env->ir[IR_SP]),
5585 &frame->uc.tuc_stack.ss_flags);
5586 __put_user(target_sigaltstack_used.ss_size,
5587 &frame->uc.tuc_stack.ss_size);
60e99246 5588 err |= setup_sigcontext(&frame->uc.tuc_mcontext, env, frame_addr, set);
6049f4f8 5589 for (i = 0; i < TARGET_NSIG_WORDS; ++i) {
1d8b512b 5590 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
6049f4f8
RH		 5591 }
5592
5593 if (ka->sa_restorer) {
5594 r26 = ka->sa_restorer;
5595 } else {
1d8b512b
RV		 5596 __put_user(INSN_MOV_R30_R16, &frame->retcode[0]);
5597 __put_user(INSN_LDI_R0 + TARGET_NR_rt_sigreturn,
5598 &frame->retcode[1]);
5599 __put_user(INSN_CALLSYS, &frame->retcode[2]);
6049f4f8
RH		 5600 /* imb(); */
5601 r26 = frame_addr;
5602 }
5603
5604 if (err) {
5605 give_sigsegv:
5606 if (sig == TARGET_SIGSEGV) {
5607 ka->_sa_handler = TARGET_SIG_DFL;
5608 }
5609 force_sig(TARGET_SIGSEGV);
5610 }
5611
5612 env->ir[IR_RA] = r26;
5613 env->ir[IR_PV] = env->pc = ka->_sa_handler;
5614 env->ir[IR_A0] = sig;
5615 env->ir[IR_A1] = frame_addr + offsetof(struct target_rt_sigframe, info);
5616 env->ir[IR_A2] = frame_addr + offsetof(struct target_rt_sigframe, uc);
5617 env->ir[IR_SP] = frame_addr;
5618}
5619
05390248 5620long do_sigreturn(CPUAlphaState *env)
6049f4f8
RH		 5621{
5622 struct target_sigcontext *sc;
5623 abi_ulong sc_addr = env->ir[IR_A0];
5624 target_sigset_t target_set;
5625 sigset_t set;
5626
5627 if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1)) {
5628 goto badframe;
5629 }
5630
5631 target_sigemptyset(&target_set);
5632 if (__get_user(target_set.sig[0], &sc->sc_mask)) {
5633 goto badframe;
5634 }
5635
5636 target_to_host_sigset_internal(&set, &target_set);
1c275925 5637 do_sigprocmask(SIG_SETMASK, &set, NULL);
6049f4f8
RH		 5638
5639 if (restore_sigcontext(env, sc)) {
5640 goto badframe;
5641 }
5642 unlock_user_struct(sc, sc_addr, 0);
5643 return env->ir[IR_V0];
5644
5645 badframe:
5646 unlock_user_struct(sc, sc_addr, 0);
5647 force_sig(TARGET_SIGSEGV);
5648}
5649
05390248 5650long do_rt_sigreturn(CPUAlphaState *env)
6049f4f8
RH		 5651{
5652 abi_ulong frame_addr = env->ir[IR_A0];
5653 struct target_rt_sigframe *frame;
5654 sigset_t set;
5655
5656 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
5657 goto badframe;
5658 }
60e99246 5659 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
1c275925 5660 do_sigprocmask(SIG_SETMASK, &set, NULL);
6049f4f8 5661
60e99246 5662 if (restore_sigcontext(env, &frame->uc.tuc_mcontext)) {
6049f4f8
RH		 5663 goto badframe;
5664 }
5665 if (do_sigaltstack(frame_addr + offsetof(struct target_rt_sigframe,
60e99246 5666 uc.tuc_stack),
6049f4f8
RH		 5667 0, env->ir[IR_SP]) == -EFAULT) {
5668 goto badframe;
5669 }
5670
5671 unlock_user_struct(frame, frame_addr, 0);
5672 return env->ir[IR_V0];
5673
5674
5675 badframe:
5676 unlock_user_struct(frame, frame_addr, 0);
5677 force_sig(TARGET_SIGSEGV);
5678}
5679
b346ff46
FB		 5680#else
5681
624f7979 5682static void setup_frame(int sig, struct target_sigaction *ka,
9349b4f9 5683 target_sigset_t *set, CPUArchState *env)
b346ff46
FB		 5684{
5685 fprintf(stderr, "setup_frame: not implemented\n");
5686}
5687
624f7979 5688static void setup_rt_frame(int sig, struct target_sigaction *ka,
c227f099 5689 target_siginfo_t *info,
9349b4f9 5690 target_sigset_t *set, CPUArchState *env)
b346ff46
FB		 5691{
5692 fprintf(stderr, "setup_rt_frame: not implemented\n");
5693}
5694
9349b4f9 5695long do_sigreturn(CPUArchState *env)
b346ff46
FB		 5696{
5697 fprintf(stderr, "do_sigreturn: not implemented\n");
f8b0aa25 5698 return -TARGET_ENOSYS;
b346ff46
FB		 5699}
5700
9349b4f9 5701long do_rt_sigreturn(CPUArchState *env)
b346ff46
FB		 5702{
5703 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
f8b0aa25 5704 return -TARGET_ENOSYS;
b346ff46
FB		 5705}
5706
66fb9763
FB		 5707#endif
5708
9349b4f9 5709void process_pending_signals(CPUArchState *cpu_env)
66fb9763 5710{
db6b81d4 5711 CPUState *cpu = ENV_GET_CPU(cpu_env);
66fb9763 5712 int sig;
992f48a0 5713 abi_ulong handler;
9de5e440 5714 sigset_t set, old_set;
c227f099 5715 target_sigset_t target_old_set;
624f7979
PB		 5716 struct emulated_sigtable *k;
5717 struct target_sigaction *sa;
66fb9763 5718 struct sigqueue *q;
0429a971 5719 TaskState *ts = cpu->opaque;
3b46e624 5720
624f7979 5721 if (!ts->signal_pending)
31e31b8a
FB		 5722 return;
5723
624f7979
PB		 5724 /* FIXME: This is not threadsafe. */
5725 k = ts->sigtab;
66fb9763
FB		 5726 for(sig = 1; sig <= TARGET_NSIG; sig++) {
5727 if (k->pending)
31e31b8a 5728 goto handle_signal;
66fb9763 5729 k++;
31e31b8a
FB		 5730 }
5731 /* if no signal is pending, just return */
624f7979 5732 ts->signal_pending = 0;
31e31b8a 5733 return;
66fb9763 5734
31e31b8a 5735 handle_signal:
66fb9763 5736#ifdef DEBUG_SIGNAL
bc8a22cc 5737 fprintf(stderr, "qemu: process signal %d\n", sig);
66fb9763
FB		 5738#endif
5739 /* dequeue signal */
5740 q = k->first;
5741 k->first = q->next;
5742 if (!k->first)
5743 k->pending = 0;
3b46e624 5744
db6b81d4 5745 sig = gdb_handlesig(cpu, sig);
1fddef4b 5746 if (!sig) {
ca587a8e
AJ		 5747 sa = NULL;
5748 handler = TARGET_SIG_IGN;
5749 } else {
5750 sa = &sigact_table[sig - 1];
5751 handler = sa->_sa_handler;
1fddef4b 5752 }
66fb9763 5753
a7ec0f98
PM		 5754 if (ts->sigsegv_blocked && sig == TARGET_SIGSEGV) {
5755 /* Guest has blocked SIGSEGV but we got one anyway. Assume this
5756 * is a forced SIGSEGV (ie one the kernel handles via force_sig_info
5757 * because it got a real MMU fault), and treat as if default handler.
5758 */
5759 handler = TARGET_SIG_DFL;
5760 }
5761
66fb9763 5762 if (handler == TARGET_SIG_DFL) {
ca587a8e
AJ		 5763 /* default handler : ignore some signal. The other are job control or fatal */
5764 if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) {
5765 kill(getpid(),SIGSTOP);
5766 } else if (sig != TARGET_SIGCHLD &&
5767 sig != TARGET_SIGURG &&
5768 sig != TARGET_SIGWINCH &&
5769 sig != TARGET_SIGCONT) {
66fb9763
FB		 5770 force_sig(sig);
5771 }
5772 } else if (handler == TARGET_SIG_IGN) {
5773 /* ignore sig */
5774 } else if (handler == TARGET_SIG_ERR) {
5775 force_sig(sig);
5776 } else {
9de5e440 5777 /* compute the blocked signals during the handler execution */
624f7979 5778 target_to_host_sigset(&set, &sa->sa_mask);
9de5e440
FB		 5779 /* SA_NODEFER indicates that the current signal should not be
5780 blocked during the handler */
624f7979 5781 if (!(sa->sa_flags & TARGET_SA_NODEFER))
9de5e440 5782 sigaddset(&set, target_to_host_signal(sig));
3b46e624 5783
9de5e440 5784 /* block signals in the handler using Linux */
1c275925 5785 do_sigprocmask(SIG_BLOCK, &set, &old_set);
9de5e440
FB		 5786 /* save the previous blocked signal state to restore it at the
5787 end of the signal execution (see do_sigreturn) */
9231944d 5788 host_to_target_sigset_internal(&target_old_set, &old_set);
9de5e440 5789
bc8a22cc 5790 /* if the CPU is in VM86 mode, we restore the 32 bit values */
84409ddb 5791#if defined(TARGET_I386) && !defined(TARGET_X86_64)
bc8a22cc
FB		 5792 {
5793 CPUX86State *env = cpu_env;
5794 if (env->eflags & VM_MASK)
5795 save_v86_state(env);
5796 }
5797#endif
9de5e440 5798 /* prepare the stack frame of the virtual CPU */
ff970904
RH		 5799#if defined(TARGET_ABI_MIPSN32) || defined(TARGET_ABI_MIPSN64)
5800 /* These targets do not have traditional signals. */
5801 setup_rt_frame(sig, sa, &q->info, &target_old_set, cpu_env);
5802#else
624f7979
PB		 5803 if (sa->sa_flags & TARGET_SA_SIGINFO)
5804 setup_rt_frame(sig, sa, &q->info, &target_old_set, cpu_env);
66fb9763 5805 else
624f7979 5806 setup_frame(sig, sa, &target_old_set, cpu_env);
ff970904 5807#endif
624f7979
PB		 5808 if (sa->sa_flags & TARGET_SA_RESETHAND)
5809 sa->_sa_handler = TARGET_SIG_DFL;
31e31b8a 5810 }
66fb9763 5811 if (q != &k->info)
624f7979 5812 free_sigqueue(cpu_env, q);
66fb9763 5813}
QEMU mirror