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