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