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