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