]> 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
mac99: fix segmentation fault on startup
[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>
31e31b8a 24#include <signal.h>
66fb9763 25#include <errno.h>
603e4fd7 26#include <assert.h>
31e31b8a 27#include <sys/ucontext.h>
edf8e2af 28#include <sys/resource.h>
31e31b8a 29
3ef693a0 30#include "qemu.h"
7d99a001 31#include "qemu-common.h"
992f48a0 32#include "target_signal.h"
66fb9763
FB		 33
34//#define DEBUG_SIGNAL
35
249c4c32 36static struct target_sigaltstack target_sigaltstack_used = {
a04e134a
TS		 37 .ss_sp = 0,
38 .ss_size = 0,
39 .ss_flags = TARGET_SS_DISABLE,
40};
41
624f7979 42static struct target_sigaction sigact_table[TARGET_NSIG];
31e31b8a 43
5fafdf24 44static void host_signal_handler(int host_signum, siginfo_t *info,
66fb9763
FB		 45 void *puc);
46
9e5f5284
FB		 47static uint8_t host_to_target_signal_table[65] = {
48 [SIGHUP] = TARGET_SIGHUP,
49 [SIGINT] = TARGET_SIGINT,
50 [SIGQUIT] = TARGET_SIGQUIT,
51 [SIGILL] = TARGET_SIGILL,
52 [SIGTRAP] = TARGET_SIGTRAP,
53 [SIGABRT] = TARGET_SIGABRT,
01e3b763 54/* [SIGIOT] = TARGET_SIGIOT,*/
9e5f5284
FB		 55 [SIGBUS] = TARGET_SIGBUS,
56 [SIGFPE] = TARGET_SIGFPE,
57 [SIGKILL] = TARGET_SIGKILL,
58 [SIGUSR1] = TARGET_SIGUSR1,
59 [SIGSEGV] = TARGET_SIGSEGV,
60 [SIGUSR2] = TARGET_SIGUSR2,
61 [SIGPIPE] = TARGET_SIGPIPE,
62 [SIGALRM] = TARGET_SIGALRM,
63 [SIGTERM] = TARGET_SIGTERM,
64#ifdef SIGSTKFLT
65 [SIGSTKFLT] = TARGET_SIGSTKFLT,
66#endif
67 [SIGCHLD] = TARGET_SIGCHLD,
68 [SIGCONT] = TARGET_SIGCONT,
69 [SIGSTOP] = TARGET_SIGSTOP,
70 [SIGTSTP] = TARGET_SIGTSTP,
71 [SIGTTIN] = TARGET_SIGTTIN,
72 [SIGTTOU] = TARGET_SIGTTOU,
73 [SIGURG] = TARGET_SIGURG,
74 [SIGXCPU] = TARGET_SIGXCPU,
75 [SIGXFSZ] = TARGET_SIGXFSZ,
76 [SIGVTALRM] = TARGET_SIGVTALRM,
77 [SIGPROF] = TARGET_SIGPROF,
78 [SIGWINCH] = TARGET_SIGWINCH,
79 [SIGIO] = TARGET_SIGIO,
80 [SIGPWR] = TARGET_SIGPWR,
81 [SIGSYS] = TARGET_SIGSYS,
82 /* next signals stay the same */
624f7979
PB		 83 /* Nasty hack: Reverse SIGRTMIN and SIGRTMAX to avoid overlap with
84 host libpthread signals. This assumes noone actually uses SIGRTMAX :-/
85 To fix this properly we need to do manual signal delivery multiplexed
86 over a single host signal. */
87 [__SIGRTMIN] = __SIGRTMAX,
88 [__SIGRTMAX] = __SIGRTMIN,
9e5f5284
FB		 89};
90static uint8_t target_to_host_signal_table[65];
91
a04e134a
TS		 92static inline int on_sig_stack(unsigned long sp)
93{
94 return (sp - target_sigaltstack_used.ss_sp
95 < target_sigaltstack_used.ss_size);
96}
97
98static inline int sas_ss_flags(unsigned long sp)
99{
100 return (target_sigaltstack_used.ss_size == 0 ? SS_DISABLE
101 : on_sig_stack(sp) ? SS_ONSTACK : 0);
102}
103
1d9d8b55 104int host_to_target_signal(int sig)
31e31b8a 105{
4cb05961
PB		 106 if (sig > 64)
107 return sig;
9e5f5284 108 return host_to_target_signal_table[sig];
31e31b8a
FB		 109}
110
4cb05961 111int target_to_host_signal(int sig)
31e31b8a 112{
4cb05961
PB		 113 if (sig > 64)
114 return sig;
9e5f5284 115 return target_to_host_signal_table[sig];
31e31b8a
FB		 116}
117
f5545b5c
PB		 118static inline void target_sigemptyset(target_sigset_t *set)
119{
120 memset(set, 0, sizeof(*set));
121}
122
123static inline void target_sigaddset(target_sigset_t *set, int signum)
124{
125 signum--;
126 abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW);
127 set->sig[signum / TARGET_NSIG_BPW] |= mask;
128}
129
130static inline int target_sigismember(const target_sigset_t *set, int signum)
131{
132 signum--;
133 abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW);
134 return ((set->sig[signum / TARGET_NSIG_BPW] & mask) != 0);
135}
136
5fafdf24 137static void host_to_target_sigset_internal(target_sigset_t *d,
9231944d 138 const sigset_t *s)
66fb9763
FB		 139{
140 int i;
f5545b5c
PB		 141 target_sigemptyset(d);
142 for (i = 1; i <= TARGET_NSIG; i++) {
143 if (sigismember(s, i)) {
144 target_sigaddset(d, host_to_target_signal(i));
145 }
66fb9763
FB		 146 }
147}
148
9231944d
FB		 149void host_to_target_sigset(target_sigset_t *d, const sigset_t *s)
150{
151 target_sigset_t d1;
152 int i;
153
154 host_to_target_sigset_internal(&d1, s);
155 for(i = 0;i < TARGET_NSIG_WORDS; i++)
53a5960a 156 d->sig[i] = tswapl(d1.sig[i]);
9231944d
FB		 157}
158
8fcd3692
BS		 159static void target_to_host_sigset_internal(sigset_t *d,
160 const target_sigset_t *s)
66fb9763
FB		 161{
162 int i;
f5545b5c
PB		 163 sigemptyset(d);
164 for (i = 1; i <= TARGET_NSIG; i++) {
165 if (target_sigismember(s, i)) {
166 sigaddset(d, target_to_host_signal(i));
167 }
168 }
66fb9763
FB		 169}
170
9231944d
FB		 171void target_to_host_sigset(sigset_t *d, const target_sigset_t *s)
172{
173 target_sigset_t s1;
174 int i;
175
176 for(i = 0;i < TARGET_NSIG_WORDS; i++)
53a5960a 177 s1.sig[i] = tswapl(s->sig[i]);
9231944d
FB		 178 target_to_host_sigset_internal(d, &s1);
179}
3b46e624 180
992f48a0 181void host_to_target_old_sigset(abi_ulong *old_sigset,
66fb9763
FB		 182 const sigset_t *sigset)
183{
9e5f5284
FB		 184 target_sigset_t d;
185 host_to_target_sigset(&d, sigset);
186 *old_sigset = d.sig[0];
66fb9763
FB		 187}
188
5fafdf24 189void target_to_host_old_sigset(sigset_t *sigset,
992f48a0 190 const abi_ulong *old_sigset)
66fb9763 191{
9e5f5284
FB		 192 target_sigset_t d;
193 int i;
194
195 d.sig[0] = *old_sigset;
196 for(i = 1;i < TARGET_NSIG_WORDS; i++)
197 d.sig[i] = 0;
198 target_to_host_sigset(sigset, &d);
66fb9763
FB		 199}
200
9de5e440
FB		 201/* siginfo conversion */
202
5fafdf24 203static inline void host_to_target_siginfo_noswap(target_siginfo_t *tinfo,
9de5e440 204 const siginfo_t *info)
66fb9763 205{
9de5e440
FB		 206 int sig;
207 sig = host_to_target_signal(info->si_signo);
208 tinfo->si_signo = sig;
209 tinfo->si_errno = 0;
afd7cd92 210 tinfo->si_code = info->si_code;
5fafdf24 211 if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV ||
447db213 212 sig == SIGBUS || sig == SIGTRAP) {
9de5e440
FB		 213 /* should never come here, but who knows. The information for
214 the target is irrelevant */
215 tinfo->_sifields._sigfault._addr = 0;
7f7f7c84
TS		 216 } else if (sig == SIGIO) {
217 tinfo->_sifields._sigpoll._fd = info->si_fd;
9de5e440
FB		 218 } else if (sig >= TARGET_SIGRTMIN) {
219 tinfo->_sifields._rt._pid = info->si_pid;
220 tinfo->_sifields._rt._uid = info->si_uid;
221 /* XXX: potential problem if 64 bit */
5fafdf24 222 tinfo->_sifields._rt._sigval.sival_ptr =
459a4017 223 (abi_ulong)(unsigned long)info->si_value.sival_ptr;
9de5e440
FB		 224 }
225}
226
5fafdf24 227static void tswap_siginfo(target_siginfo_t *tinfo,
9de5e440
FB		 228 const target_siginfo_t *info)
229{
230 int sig;
231 sig = info->si_signo;
232 tinfo->si_signo = tswap32(sig);
66fb9763
FB		 233 tinfo->si_errno = tswap32(info->si_errno);
234 tinfo->si_code = tswap32(info->si_code);
5fafdf24 235 if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV ||
447db213 236 sig == SIGBUS || sig == SIGTRAP) {
5fafdf24 237 tinfo->_sifields._sigfault._addr =
9de5e440 238 tswapl(info->_sifields._sigfault._addr);
7f7f7c84
TS		 239 } else if (sig == SIGIO) {
240 tinfo->_sifields._sigpoll._fd = tswap32(info->_sifields._sigpoll._fd);
9de5e440
FB		 241 } else if (sig >= TARGET_SIGRTMIN) {
242 tinfo->_sifields._rt._pid = tswap32(info->_sifields._rt._pid);
243 tinfo->_sifields._rt._uid = tswap32(info->_sifields._rt._uid);
5fafdf24 244 tinfo->_sifields._rt._sigval.sival_ptr =
9de5e440
FB		 245 tswapl(info->_sifields._rt._sigval.sival_ptr);
246 }
247}
248
249
250void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info)
251{
252 host_to_target_siginfo_noswap(tinfo, info);
253 tswap_siginfo(tinfo, tinfo);
66fb9763
FB		 254}
255
9de5e440 256/* XXX: we support only POSIX RT signals are used. */
aa1f17c1 257/* XXX: find a solution for 64 bit (additional malloced data is needed) */
9de5e440 258void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo)
66fb9763
FB		 259{
260 info->si_signo = tswap32(tinfo->si_signo);
261 info->si_errno = tswap32(tinfo->si_errno);
262 info->si_code = tswap32(tinfo->si_code);
9de5e440
FB		 263 info->si_pid = tswap32(tinfo->_sifields._rt._pid);
264 info->si_uid = tswap32(tinfo->_sifields._rt._uid);
5fafdf24 265 info->si_value.sival_ptr =
459a4017 266 (void *)(long)tswapl(tinfo->_sifields._rt._sigval.sival_ptr);
66fb9763
FB		 267}
268
ca587a8e
AJ		 269static int fatal_signal (int sig)
270{
271 switch (sig) {
272 case TARGET_SIGCHLD:
273 case TARGET_SIGURG:
274 case TARGET_SIGWINCH:
275 /* Ignored by default. */
276 return 0;
277 case TARGET_SIGCONT:
278 case TARGET_SIGSTOP:
279 case TARGET_SIGTSTP:
280 case TARGET_SIGTTIN:
281 case TARGET_SIGTTOU:
282 /* Job control signals. */
283 return 0;
284 default:
285 return 1;
286 }
287}
288
edf8e2af
MW		 289/* returns 1 if given signal should dump core if not handled */
290static int core_dump_signal(int sig)
291{
292 switch (sig) {
293 case TARGET_SIGABRT:
294 case TARGET_SIGFPE:
295 case TARGET_SIGILL:
296 case TARGET_SIGQUIT:
297 case TARGET_SIGSEGV:
298 case TARGET_SIGTRAP:
299 case TARGET_SIGBUS:
300 return (1);
301 default:
302 return (0);
303 }
304}
305
31e31b8a
FB		 306void signal_init(void)
307{
308 struct sigaction act;
624f7979 309 struct sigaction oact;
9e5f5284 310 int i, j;
624f7979 311 int host_sig;
31e31b8a 312
9e5f5284
FB		 313 /* generate signal conversion tables */
314 for(i = 1; i <= 64; i++) {
315 if (host_to_target_signal_table[i] == 0)
316 host_to_target_signal_table[i] = i;
317 }
318 for(i = 1; i <= 64; i++) {
319 j = host_to_target_signal_table[i];
320 target_to_host_signal_table[j] = i;
321 }
3b46e624 322
9de5e440
FB		 323 /* set all host signal handlers. ALL signals are blocked during
324 the handlers to serialize them. */
624f7979
PB		 325 memset(sigact_table, 0, sizeof(sigact_table));
326
9de5e440 327 sigfillset(&act.sa_mask);
31e31b8a
FB		 328 act.sa_flags = SA_SIGINFO;
329 act.sa_sigaction = host_signal_handler;
624f7979
PB		 330 for(i = 1; i <= TARGET_NSIG; i++) {
331 host_sig = target_to_host_signal(i);
332 sigaction(host_sig, NULL, &oact);
333 if (oact.sa_sigaction == (void *)SIG_IGN) {
334 sigact_table[i - 1]._sa_handler = TARGET_SIG_IGN;
335 } else if (oact.sa_sigaction == (void *)SIG_DFL) {
336 sigact_table[i - 1]._sa_handler = TARGET_SIG_DFL;
337 }
338 /* If there's already a handler installed then something has
339 gone horribly wrong, so don't even try to handle that case. */
ca587a8e
AJ		 340 /* Install some handlers for our own use. We need at least
341 SIGSEGV and SIGBUS, to detect exceptions. We can not just
342 trap all signals because it affects syscall interrupt
343 behavior. But do trap all default-fatal signals. */
344 if (fatal_signal (i))
624f7979 345 sigaction(host_sig, &act, NULL);
31e31b8a 346 }
66fb9763
FB		 347}
348
349/* signal queue handling */
350
624f7979 351static inline struct sigqueue *alloc_sigqueue(CPUState *env)
66fb9763 352{
624f7979
PB		 353 TaskState *ts = env->opaque;
354 struct sigqueue *q = ts->first_free;
66fb9763
FB		 355 if (!q)
356 return NULL;
624f7979 357 ts->first_free = q->next;
66fb9763 358 return q;
31e31b8a
FB		 359}
360
624f7979 361static inline void free_sigqueue(CPUState *env, struct sigqueue *q)
66fb9763 362{
624f7979
PB		 363 TaskState *ts = env->opaque;
364 q->next = ts->first_free;
365 ts->first_free = q;
66fb9763
FB		 366}
367
9de5e440 368/* abort execution with signal */
a5e50b26 369static void QEMU_NORETURN force_sig(int sig)
66fb9763 370{
edf8e2af
MW		 371 TaskState *ts = (TaskState *)thread_env->opaque;
372 int host_sig, core_dumped = 0;
603e4fd7 373 struct sigaction act;
66fb9763 374 host_sig = target_to_host_signal(sig);
ca587a8e 375 gdb_signalled(thread_env, sig);
603e4fd7 376
edf8e2af
MW		 377 /* dump core if supported by target binary format */
378 if (core_dump_signal(sig) && (ts->bprm->core_dump != NULL)) {
379 stop_all_tasks();
380 core_dumped =
381 ((*ts->bprm->core_dump)(sig, thread_env) == 0);
382 }
383 if (core_dumped) {
384 /* we already dumped the core of target process, we don't want
385 * a coredump of qemu itself */
386 struct rlimit nodump;
387 getrlimit(RLIMIT_CORE, &nodump);
388 nodump.rlim_cur=0;
389 setrlimit(RLIMIT_CORE, &nodump);
390 (void) fprintf(stderr, "qemu: uncaught target signal %d (%s) - %s\n",
391 sig, strsignal(host_sig), "core dumped" );
392 }
393
603e4fd7
AJ		 394 /* The proper exit code for dieing from an uncaught signal is
395 * -<signal>. The kernel doesn't allow exit() or _exit() to pass
396 * a negative value. To get the proper exit code we need to
397 * actually die from an uncaught signal. Here the default signal
398 * handler is installed, we send ourself a signal and we wait for
399 * it to arrive. */
400 sigfillset(&act.sa_mask);
401 act.sa_handler = SIG_DFL;
402 sigaction(host_sig, &act, NULL);
403
404 /* For some reason raise(host_sig) doesn't send the signal when
405 * statically linked on x86-64. */
406 kill(getpid(), host_sig);
407
408 /* Make sure the signal isn't masked (just reuse the mask inside
409 of act) */
410 sigdelset(&act.sa_mask, host_sig);
411 sigsuspend(&act.sa_mask);
412
413 /* unreachable */
414 assert(0);
415
66fb9763
FB		 416}
417
9de5e440
FB		 418/* queue a signal so that it will be send to the virtual CPU as soon
419 as possible */
624f7979 420int queue_signal(CPUState *env, int sig, target_siginfo_t *info)
31e31b8a 421{
624f7979
PB		 422 TaskState *ts = env->opaque;
423 struct emulated_sigtable *k;
9de5e440 424 struct sigqueue *q, **pq;
992f48a0 425 abi_ulong handler;
ca587a8e 426 int queue;
66fb9763 427
9de5e440 428#if defined(DEBUG_SIGNAL)
5fafdf24 429 fprintf(stderr, "queue_signal: sig=%d\n",
9de5e440 430 sig);
66fb9763 431#endif
624f7979 432 k = &ts->sigtab[sig - 1];
ca587a8e 433 queue = gdb_queuesig ();
624f7979 434 handler = sigact_table[sig - 1]._sa_handler;
ca587a8e 435 if (!queue && handler == TARGET_SIG_DFL) {
60b19691
TS		 436 if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) {
437 kill(getpid(),SIGSTOP);
438 return 0;
439 } else
66fb9763 440 /* default handler : ignore some signal. The other are fatal */
5fafdf24
TS		 441 if (sig != TARGET_SIGCHLD &&
442 sig != TARGET_SIGURG &&
60b19691
TS		 443 sig != TARGET_SIGWINCH &&
444 sig != TARGET_SIGCONT) {
66fb9763 445 force_sig(sig);
9de5e440
FB		 446 } else {
447 return 0; /* indicate ignored */
66fb9763 448 }
ca587a8e 449 } else if (!queue && handler == TARGET_SIG_IGN) {
66fb9763 450 /* ignore signal */
9de5e440 451 return 0;
ca587a8e 452 } else if (!queue && handler == TARGET_SIG_ERR) {
66fb9763
FB		 453 force_sig(sig);
454 } else {
9de5e440
FB		 455 pq = &k->first;
456 if (sig < TARGET_SIGRTMIN) {
457 /* if non real time signal, we queue exactly one signal */
458 if (!k->pending)
459 q = &k->info;
460 else
461 return 0;
462 } else {
463 if (!k->pending) {
464 /* first signal */
465 q = &k->info;
466 } else {
624f7979 467 q = alloc_sigqueue(env);
9de5e440
FB		 468 if (!q)
469 return -EAGAIN;
470 while (*pq != NULL)
471 pq = &(*pq)->next;
472 }
473 }
474 *pq = q;
475 q->info = *info;
476 q->next = NULL;
477 k->pending = 1;
478 /* signal that a new signal is pending */
624f7979 479 ts->signal_pending = 1;
9de5e440
FB		 480 return 1; /* indicates that the signal was queued */
481 }
482}
483
5fafdf24 484static void host_signal_handler(int host_signum, siginfo_t *info,
9de5e440
FB		 485 void *puc)
486{
487 int sig;
488 target_siginfo_t tinfo;
489
490 /* the CPU emulator uses some host signals to detect exceptions,
eaa449b9 491 we forward to it some signals */
ca587a8e 492 if ((host_signum == SIGSEGV || host_signum == SIGBUS)
eaa449b9 493 && info->si_code > 0) {
b346ff46 494 if (cpu_signal_handler(host_signum, info, puc))
9de5e440
FB		 495 return;
496 }
497
498 /* get target signal number */
499 sig = host_to_target_signal(host_signum);
500 if (sig < 1 || sig > TARGET_NSIG)
501 return;
502#if defined(DEBUG_SIGNAL)
bc8a22cc 503 fprintf(stderr, "qemu: got signal %d\n", sig);
9de5e440
FB		 504#endif
505 host_to_target_siginfo_noswap(&tinfo, info);
d5975363 506 if (queue_signal(thread_env, sig, &tinfo) == 1) {
9de5e440 507 /* interrupt the virtual CPU as soon as possible */
3098dba0 508 cpu_exit(thread_env);
66fb9763
FB		 509 }
510}
511
0da46a6e 512/* do_sigaltstack() returns target values and errnos. */
579a97f7
FB		 513/* compare linux/kernel/signal.c:do_sigaltstack() */
514abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp)
a04e134a
TS		 515{
516 int ret;
517 struct target_sigaltstack oss;
518
519 /* XXX: test errors */
579a97f7 520 if(uoss_addr)
a04e134a
TS		 521 {
522 __put_user(target_sigaltstack_used.ss_sp, &oss.ss_sp);
523 __put_user(target_sigaltstack_used.ss_size, &oss.ss_size);
524 __put_user(sas_ss_flags(sp), &oss.ss_flags);
525 }
526
579a97f7 527 if(uss_addr)
a04e134a 528 {
579a97f7
FB		 529 struct target_sigaltstack *uss;
530 struct target_sigaltstack ss;
a04e134a 531
0da46a6e 532 ret = -TARGET_EFAULT;
579a97f7 533 if (!lock_user_struct(VERIFY_READ, uss, uss_addr, 1)
a04e134a
TS		 534 || __get_user(ss.ss_sp, &uss->ss_sp)
535 || __get_user(ss.ss_size, &uss->ss_size)
536 || __get_user(ss.ss_flags, &uss->ss_flags))
537 goto out;
579a97f7 538 unlock_user_struct(uss, uss_addr, 0);
a04e134a 539
0da46a6e 540 ret = -TARGET_EPERM;
a04e134a
TS		 541 if (on_sig_stack(sp))
542 goto out;
543
0da46a6e 544 ret = -TARGET_EINVAL;
a04e134a
TS		 545 if (ss.ss_flags != TARGET_SS_DISABLE
546 && ss.ss_flags != TARGET_SS_ONSTACK
547 && ss.ss_flags != 0)
548 goto out;
549
550 if (ss.ss_flags == TARGET_SS_DISABLE) {
551 ss.ss_size = 0;
552 ss.ss_sp = 0;
553 } else {
0da46a6e 554 ret = -TARGET_ENOMEM;
a04e134a
TS		 555 if (ss.ss_size < MINSIGSTKSZ)
556 goto out;
557 }
558
559 target_sigaltstack_used.ss_sp = ss.ss_sp;
560 target_sigaltstack_used.ss_size = ss.ss_size;
561 }
562
579a97f7 563 if (uoss_addr) {
0da46a6e 564 ret = -TARGET_EFAULT;
579a97f7 565 if (copy_to_user(uoss_addr, &oss, sizeof(oss)))
a04e134a 566 goto out;
a04e134a
TS		 567 }
568
569 ret = 0;
570out:
571 return ret;
572}
573
0da46a6e 574/* do_sigaction() return host values and errnos */
66fb9763
FB		 575int do_sigaction(int sig, const struct target_sigaction *act,
576 struct target_sigaction *oact)
577{
624f7979 578 struct target_sigaction *k;
773b93ee
FB		 579 struct sigaction act1;
580 int host_sig;
0da46a6e 581 int ret = 0;
66fb9763 582
2a913eb1 583 if (sig < 1 || sig > TARGET_NSIG || sig == TARGET_SIGKILL || sig == TARGET_SIGSTOP)
66fb9763
FB		 584 return -EINVAL;
585 k = &sigact_table[sig - 1];
773b93ee 586#if defined(DEBUG_SIGNAL)
dd500a92
BS		 587 fprintf(stderr, "sigaction sig=%d act=0x%p, oact=0x%p\n",
588 sig, act, oact);
66fb9763
FB		 589#endif
590 if (oact) {
624f7979
PB		 591 oact->_sa_handler = tswapl(k->_sa_handler);
592 oact->sa_flags = tswapl(k->sa_flags);
388bb21a 593#if !defined(TARGET_MIPS)
624f7979 594 oact->sa_restorer = tswapl(k->sa_restorer);
388bb21a 595#endif
624f7979 596 oact->sa_mask = k->sa_mask;
66fb9763
FB		 597 }
598 if (act) {
624f7979
PB		 599 /* FIXME: This is not threadsafe. */
600 k->_sa_handler = tswapl(act->_sa_handler);
601 k->sa_flags = tswapl(act->sa_flags);
388bb21a 602#if !defined(TARGET_MIPS)
624f7979 603 k->sa_restorer = tswapl(act->sa_restorer);
388bb21a 604#endif
624f7979 605 k->sa_mask = act->sa_mask;
773b93ee
FB		 606
607 /* we update the host linux signal state */
608 host_sig = target_to_host_signal(sig);
609 if (host_sig != SIGSEGV && host_sig != SIGBUS) {
610 sigfillset(&act1.sa_mask);
611 act1.sa_flags = SA_SIGINFO;
624f7979 612 if (k->sa_flags & TARGET_SA_RESTART)
773b93ee
FB		 613 act1.sa_flags |= SA_RESTART;
614 /* NOTE: it is important to update the host kernel signal
615 ignore state to avoid getting unexpected interrupted
616 syscalls */
624f7979 617 if (k->_sa_handler == TARGET_SIG_IGN) {
773b93ee 618 act1.sa_sigaction = (void *)SIG_IGN;
624f7979 619 } else if (k->_sa_handler == TARGET_SIG_DFL) {
ca587a8e
AJ		 620 if (fatal_signal (sig))
621 act1.sa_sigaction = host_signal_handler;
622 else
623 act1.sa_sigaction = (void *)SIG_DFL;
773b93ee
FB		 624 } else {
625 act1.sa_sigaction = host_signal_handler;
626 }
0da46a6e 627 ret = sigaction(host_sig, &act1, NULL);
773b93ee 628 }
66fb9763 629 }
0da46a6e 630 return ret;
66fb9763
FB		 631}
632
5fafdf24 633static inline int copy_siginfo_to_user(target_siginfo_t *tinfo,
43fff238
FB		 634 const target_siginfo_t *info)
635{
636 tswap_siginfo(tinfo, info);
637 return 0;
638}
639
c3b5bc8a
TS		 640static inline int current_exec_domain_sig(int sig)
641{
642 return /* current->exec_domain && current->exec_domain->signal_invmap
643 && sig < 32 ? current->exec_domain->signal_invmap[sig] : */ sig;
644}
645
459a4017 646#if defined(TARGET_I386) && TARGET_ABI_BITS == 32
66fb9763
FB		 647
648/* from the Linux kernel */
649
650struct target_fpreg {
651 uint16_t significand[4];
652 uint16_t exponent;
653};
654
655struct target_fpxreg {
656 uint16_t significand[4];
657 uint16_t exponent;
658 uint16_t padding[3];
659};
660
661struct target_xmmreg {
992f48a0 662 abi_ulong element[4];
66fb9763
FB		 663};
664
665struct target_fpstate {
666 /* Regular FPU environment */
992f48a0
BS		 667 abi_ulong cw;
668 abi_ulong sw;
669 abi_ulong tag;
670 abi_ulong ipoff;
671 abi_ulong cssel;
672 abi_ulong dataoff;
673 abi_ulong datasel;
66fb9763
FB		 674 struct target_fpreg _st[8];
675 uint16_t status;
676 uint16_t magic; /* 0xffff = regular FPU data only */
677
678 /* FXSR FPU environment */
992f48a0
BS		 679 abi_ulong _fxsr_env[6]; /* FXSR FPU env is ignored */
680 abi_ulong mxcsr;
681 abi_ulong reserved;
66fb9763
FB		 682 struct target_fpxreg _fxsr_st[8]; /* FXSR FPU reg data is ignored */
683 struct target_xmmreg _xmm[8];
992f48a0 684 abi_ulong padding[56];
66fb9763
FB		 685};
686
687#define X86_FXSR_MAGIC 0x0000
688
689struct target_sigcontext {
690 uint16_t gs, __gsh;
691 uint16_t fs, __fsh;
692 uint16_t es, __esh;
693 uint16_t ds, __dsh;
992f48a0
BS		 694 abi_ulong edi;
695 abi_ulong esi;
696 abi_ulong ebp;
697 abi_ulong esp;
698 abi_ulong ebx;
699 abi_ulong edx;
700 abi_ulong ecx;
701 abi_ulong eax;
702 abi_ulong trapno;
703 abi_ulong err;
704 abi_ulong eip;
66fb9763 705 uint16_t cs, __csh;
992f48a0
BS		 706 abi_ulong eflags;
707 abi_ulong esp_at_signal;
66fb9763 708 uint16_t ss, __ssh;
992f48a0
BS		 709 abi_ulong fpstate; /* pointer */
710 abi_ulong oldmask;
711 abi_ulong cr2;
66fb9763
FB		 712};
713
66fb9763 714struct target_ucontext {
992f48a0
BS		 715 abi_ulong tuc_flags;
716 abi_ulong tuc_link;
b8076a74
FB		 717 target_stack_t tuc_stack;
718 struct target_sigcontext tuc_mcontext;
719 target_sigset_t tuc_sigmask; /* mask last for extensibility */
66fb9763
FB		 720};
721
722struct sigframe
723{
992f48a0 724 abi_ulong pretcode;
66fb9763
FB		 725 int sig;
726 struct target_sigcontext sc;
727 struct target_fpstate fpstate;
992f48a0 728 abi_ulong extramask[TARGET_NSIG_WORDS-1];
66fb9763
FB		 729 char retcode[8];
730};
731
732struct rt_sigframe
733{
992f48a0 734 abi_ulong pretcode;
66fb9763 735 int sig;
992f48a0
BS		 736 abi_ulong pinfo;
737 abi_ulong puc;
66fb9763
FB		 738 struct target_siginfo info;
739 struct target_ucontext uc;
740 struct target_fpstate fpstate;
741 char retcode[8];
742};
743
744/*
745 * Set up a signal frame.
746 */
747
66fb9763
FB		 748/* XXX: save x87 state */
749static int
750setup_sigcontext(struct target_sigcontext *sc, struct target_fpstate *fpstate,
28be6234 751 CPUX86State *env, abi_ulong mask, abi_ulong fpstate_addr)
66fb9763
FB		 752{
753 int err = 0;
775b58d8 754 uint16_t magic;
66fb9763 755
579a97f7 756 /* already locked in setup_frame() */
a52c757c
FB		 757 err |= __put_user(env->segs[R_GS].selector, (unsigned int *)&sc->gs);
758 err |= __put_user(env->segs[R_FS].selector, (unsigned int *)&sc->fs);
759 err |= __put_user(env->segs[R_ES].selector, (unsigned int *)&sc->es);
760 err |= __put_user(env->segs[R_DS].selector, (unsigned int *)&sc->ds);
66fb9763
FB		 761 err |= __put_user(env->regs[R_EDI], &sc->edi);
762 err |= __put_user(env->regs[R_ESI], &sc->esi);
763 err |= __put_user(env->regs[R_EBP], &sc->ebp);
764 err |= __put_user(env->regs[R_ESP], &sc->esp);
765 err |= __put_user(env->regs[R_EBX], &sc->ebx);
766 err |= __put_user(env->regs[R_EDX], &sc->edx);
767 err |= __put_user(env->regs[R_ECX], &sc->ecx);
768 err |= __put_user(env->regs[R_EAX], &sc->eax);
66099dd9
FB		 769 err |= __put_user(env->exception_index, &sc->trapno);
770 err |= __put_user(env->error_code, &sc->err);
66fb9763 771 err |= __put_user(env->eip, &sc->eip);
a52c757c 772 err |= __put_user(env->segs[R_CS].selector, (unsigned int *)&sc->cs);
66fb9763
FB		 773 err |= __put_user(env->eflags, &sc->eflags);
774 err |= __put_user(env->regs[R_ESP], &sc->esp_at_signal);
a52c757c 775 err |= __put_user(env->segs[R_SS].selector, (unsigned int *)&sc->ss);
ed2dcdf6 776
28be6234 777 cpu_x86_fsave(env, fpstate_addr, 1);
ed2dcdf6 778 fpstate->status = fpstate->sw;
775b58d8
FB		 779 magic = 0xffff;
780 err |= __put_user(magic, &fpstate->magic);
28be6234 781 err |= __put_user(fpstate_addr, &sc->fpstate);
ed2dcdf6 782
66fb9763
FB		 783 /* non-iBCS2 extensions.. */
784 err |= __put_user(mask, &sc->oldmask);
a52c757c 785 err |= __put_user(env->cr[2], &sc->cr2);
66fb9763 786 return err;
31e31b8a
FB		 787}
788
66fb9763
FB		 789/*
790 * Determine which stack to use..
791 */
31e31b8a 792
579a97f7 793static inline abi_ulong
624f7979 794get_sigframe(struct target_sigaction *ka, CPUX86State *env, size_t frame_size)
31e31b8a 795{
66fb9763
FB		 796 unsigned long esp;
797
798 /* Default to using normal stack */
799 esp = env->regs[R_ESP];
66fb9763 800 /* This is the X/Open sanctioned signal stack switching. */
624f7979 801 if (ka->sa_flags & TARGET_SA_ONSTACK) {
a04e134a
TS		 802 if (sas_ss_flags(esp) == 0)
803 esp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
804 }
66fb9763
FB		 805
806 /* This is the legacy signal stack switching. */
5fafdf24 807 else
a52c757c 808 if ((env->segs[R_SS].selector & 0xffff) != __USER_DS &&
624f7979
PB		 809 !(ka->sa_flags & TARGET_SA_RESTORER) &&
810 ka->sa_restorer) {
811 esp = (unsigned long) ka->sa_restorer;
a52c757c 812 }
579a97f7 813 return (esp - frame_size) & -8ul;
66fb9763
FB		 814}
815
579a97f7 816/* compare linux/arch/i386/kernel/signal.c:setup_frame() */
624f7979 817static void setup_frame(int sig, struct target_sigaction *ka,
66fb9763
FB		 818 target_sigset_t *set, CPUX86State *env)
819{
579a97f7 820 abi_ulong frame_addr;
66fb9763 821 struct sigframe *frame;
9231944d 822 int i, err = 0;
66fb9763 823
579a97f7 824 frame_addr = get_sigframe(ka, env, sizeof(*frame));
66fb9763 825
579a97f7 826 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
66fb9763 827 goto give_sigsegv;
579a97f7 828
c3b5bc8a 829 err |= __put_user(current_exec_domain_sig(sig),
66fb9763
FB		 830 &frame->sig);
831 if (err)
832 goto give_sigsegv;
833
28be6234
FB		 834 setup_sigcontext(&frame->sc, &frame->fpstate, env, set->sig[0],
835 frame_addr + offsetof(struct sigframe, fpstate));
66fb9763
FB		 836 if (err)
837 goto give_sigsegv;
838
9231944d
FB		 839 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
840 if (__put_user(set->sig[i], &frame->extramask[i - 1]))
841 goto give_sigsegv;
842 }
66fb9763
FB		 843
844 /* Set up to return from userspace. If provided, use a stub
845 already in userspace. */
624f7979
PB		 846 if (ka->sa_flags & TARGET_SA_RESTORER) {
847 err |= __put_user(ka->sa_restorer, &frame->pretcode);
66fb9763 848 } else {
775b58d8 849 uint16_t val16;
28be6234
FB		 850 abi_ulong retcode_addr;
851 retcode_addr = frame_addr + offsetof(struct sigframe, retcode);
852 err |= __put_user(retcode_addr, &frame->pretcode);
66fb9763 853 /* This is popl %eax ; movl $,%eax ; int $0x80 */
775b58d8
FB		 854 val16 = 0xb858;
855 err |= __put_user(val16, (uint16_t *)(frame->retcode+0));
66fb9763 856 err |= __put_user(TARGET_NR_sigreturn, (int *)(frame->retcode+2));
775b58d8
FB		 857 val16 = 0x80cd;
858 err |= __put_user(val16, (uint16_t *)(frame->retcode+6));
66fb9763
FB		 859 }
860
861 if (err)
862 goto give_sigsegv;
863
864 /* Set up registers for signal handler */
28be6234 865 env->regs[R_ESP] = frame_addr;
624f7979 866 env->eip = ka->_sa_handler;
66fb9763
FB		 867
868 cpu_x86_load_seg(env, R_DS, __USER_DS);
869 cpu_x86_load_seg(env, R_ES, __USER_DS);
870 cpu_x86_load_seg(env, R_SS, __USER_DS);
871 cpu_x86_load_seg(env, R_CS, __USER_CS);
872 env->eflags &= ~TF_MASK;
873
579a97f7
FB		 874 unlock_user_struct(frame, frame_addr, 1);
875
66fb9763
FB		 876 return;
877
878give_sigsegv:
579a97f7 879 unlock_user_struct(frame, frame_addr, 1);
66fb9763 880 if (sig == TARGET_SIGSEGV)
624f7979 881 ka->_sa_handler = TARGET_SIG_DFL;
66fb9763
FB		 882 force_sig(TARGET_SIGSEGV /* , current */);
883}
884
579a97f7 885/* compare linux/arch/i386/kernel/signal.c:setup_rt_frame() */
624f7979 886static void setup_rt_frame(int sig, struct target_sigaction *ka,
9de5e440 887 target_siginfo_t *info,
66fb9763
FB		 888 target_sigset_t *set, CPUX86State *env)
889{
28be6234 890 abi_ulong frame_addr, addr;
66fb9763 891 struct rt_sigframe *frame;
9231944d 892 int i, err = 0;
66fb9763 893
579a97f7 894 frame_addr = get_sigframe(ka, env, sizeof(*frame));
66fb9763 895
579a97f7 896 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
66fb9763 897 goto give_sigsegv;
66fb9763 898
c3b5bc8a 899 err |= __put_user(current_exec_domain_sig(sig),
66fb9763 900 &frame->sig);
28be6234
FB		 901 addr = frame_addr + offsetof(struct rt_sigframe, info);
902 err |= __put_user(addr, &frame->pinfo);
903 addr = frame_addr + offsetof(struct rt_sigframe, uc);
904 err |= __put_user(addr, &frame->puc);
66fb9763
FB		 905 err |= copy_siginfo_to_user(&frame->info, info);
906 if (err)
907 goto give_sigsegv;
31e31b8a 908
66fb9763 909 /* Create the ucontext. */
b8076a74
FB		 910 err |= __put_user(0, &frame->uc.tuc_flags);
911 err |= __put_user(0, &frame->uc.tuc_link);
a04e134a 912 err |= __put_user(target_sigaltstack_used.ss_sp,
b8076a74 913 &frame->uc.tuc_stack.ss_sp);
a04e134a 914 err |= __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
b8076a74 915 &frame->uc.tuc_stack.ss_flags);
a04e134a 916 err |= __put_user(target_sigaltstack_used.ss_size,
b8076a74
FB		 917 &frame->uc.tuc_stack.ss_size);
918 err |= setup_sigcontext(&frame->uc.tuc_mcontext, &frame->fpstate,
28be6234
FB		 919 env, set->sig[0],
920 frame_addr + offsetof(struct rt_sigframe, fpstate));
9231944d 921 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
b8076a74 922 if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
9231944d
FB		 923 goto give_sigsegv;
924 }
31e31b8a 925
66fb9763
FB		 926 /* Set up to return from userspace. If provided, use a stub
927 already in userspace. */
624f7979
PB		 928 if (ka->sa_flags & TARGET_SA_RESTORER) {
929 err |= __put_user(ka->sa_restorer, &frame->pretcode);
66fb9763 930 } else {
775b58d8 931 uint16_t val16;
28be6234
FB		 932 addr = frame_addr + offsetof(struct rt_sigframe, retcode);
933 err |= __put_user(addr, &frame->pretcode);
66fb9763 934 /* This is movl $,%eax ; int $0x80 */
775b58d8 935 err |= __put_user(0xb8, (char *)(frame->retcode+0));
66fb9763 936 err |= __put_user(TARGET_NR_rt_sigreturn, (int *)(frame->retcode+1));
775b58d8
FB		 937 val16 = 0x80cd;
938 err |= __put_user(val16, (uint16_t *)(frame->retcode+5));
66fb9763
FB		 939 }
940
941 if (err)
942 goto give_sigsegv;
943
944 /* Set up registers for signal handler */
28be6234 945 env->regs[R_ESP] = frame_addr;
624f7979 946 env->eip = ka->_sa_handler;
66fb9763
FB		 947
948 cpu_x86_load_seg(env, R_DS, __USER_DS);
949 cpu_x86_load_seg(env, R_ES, __USER_DS);
950 cpu_x86_load_seg(env, R_SS, __USER_DS);
951 cpu_x86_load_seg(env, R_CS, __USER_CS);
952 env->eflags &= ~TF_MASK;
953
579a97f7
FB		 954 unlock_user_struct(frame, frame_addr, 1);
955
66fb9763
FB		 956 return;
957
958give_sigsegv:
579a97f7 959 unlock_user_struct(frame, frame_addr, 1);
66fb9763 960 if (sig == TARGET_SIGSEGV)
624f7979 961 ka->_sa_handler = TARGET_SIG_DFL;
66fb9763
FB		 962 force_sig(TARGET_SIGSEGV /* , current */);
963}
964
965static int
966restore_sigcontext(CPUX86State *env, struct target_sigcontext *sc, int *peax)
967{
968 unsigned int err = 0;
28be6234
FB		 969 abi_ulong fpstate_addr;
970 unsigned int tmpflags;
971
972 cpu_x86_load_seg(env, R_GS, tswap16(sc->gs));
973 cpu_x86_load_seg(env, R_FS, tswap16(sc->fs));
974 cpu_x86_load_seg(env, R_ES, tswap16(sc->es));
975 cpu_x86_load_seg(env, R_DS, tswap16(sc->ds));
976
977 env->regs[R_EDI] = tswapl(sc->edi);
978 env->regs[R_ESI] = tswapl(sc->esi);
979 env->regs[R_EBP] = tswapl(sc->ebp);
980 env->regs[R_ESP] = tswapl(sc->esp);
981 env->regs[R_EBX] = tswapl(sc->ebx);
982 env->regs[R_EDX] = tswapl(sc->edx);
983 env->regs[R_ECX] = tswapl(sc->ecx);
984 env->eip = tswapl(sc->eip);
66fb9763
FB		 985
986 cpu_x86_load_seg(env, R_CS, lduw(&sc->cs) | 3);
987 cpu_x86_load_seg(env, R_SS, lduw(&sc->ss) | 3);
5fafdf24 988
28be6234
FB		 989 tmpflags = tswapl(sc->eflags);
990 env->eflags = (env->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);
991 // regs->orig_eax = -1; /* disable syscall checks */
66fb9763 992
28be6234
FB		 993 fpstate_addr = tswapl(sc->fpstate);
994 if (fpstate_addr != 0) {
995 if (!access_ok(VERIFY_READ, fpstate_addr,
996 sizeof(struct target_fpstate)))
997 goto badframe;
998 cpu_x86_frstor(env, fpstate_addr, 1);
66fb9763 999 }
ed2dcdf6 1000
28be6234 1001 *peax = tswapl(sc->eax);
66fb9763 1002 return err;
66fb9763
FB		 1003badframe:
1004 return 1;
66fb9763
FB		 1005}
1006
1007long do_sigreturn(CPUX86State *env)
1008{
579a97f7
FB		 1009 struct sigframe *frame;
1010 abi_ulong frame_addr = env->regs[R_ESP] - 8;
66fb9763
FB		 1011 target_sigset_t target_set;
1012 sigset_t set;
1013 int eax, i;
1014
447db213
FB		 1015#if defined(DEBUG_SIGNAL)
1016 fprintf(stderr, "do_sigreturn\n");
1017#endif
579a97f7
FB		 1018 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1019 goto badframe;
66fb9763 1020 /* set blocked signals */
9231944d
FB		 1021 if (__get_user(target_set.sig[0], &frame->sc.oldmask))
1022 goto badframe;
1023 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1024 if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
1025 goto badframe;
1026 }
66fb9763 1027
9231944d 1028 target_to_host_sigset_internal(&set, &target_set);
66fb9763 1029 sigprocmask(SIG_SETMASK, &set, NULL);
3b46e624 1030
66fb9763
FB		 1031 /* restore registers */
1032 if (restore_sigcontext(env, &frame->sc, &eax))
1033 goto badframe;
579a97f7 1034 unlock_user_struct(frame, frame_addr, 0);
66fb9763
FB		 1035 return eax;
1036
1037badframe:
579a97f7 1038 unlock_user_struct(frame, frame_addr, 0);
66fb9763
FB		 1039 force_sig(TARGET_SIGSEGV);
1040 return 0;
1041}
1042
1043long do_rt_sigreturn(CPUX86State *env)
1044{
28be6234
FB		 1045 abi_ulong frame_addr;
1046 struct rt_sigframe *frame;
66fb9763 1047 sigset_t set;
66fb9763
FB		 1048 int eax;
1049
28be6234
FB		 1050 frame_addr = env->regs[R_ESP] - 4;
1051 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1052 goto badframe;
b8076a74 1053 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
66fb9763 1054 sigprocmask(SIG_SETMASK, &set, NULL);
5fafdf24 1055
b8076a74 1056 if (restore_sigcontext(env, &frame->uc.tuc_mcontext, &eax))
66fb9763
FB		 1057 goto badframe;
1058
28be6234
FB		 1059 if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe, uc.tuc_stack), 0,
1060 get_sp_from_cpustate(env)) == -EFAULT)
66fb9763 1061 goto badframe;
a04e134a 1062
28be6234 1063 unlock_user_struct(frame, frame_addr, 0);
66fb9763
FB		 1064 return eax;
1065
1066badframe:
28be6234
FB		 1067 unlock_user_struct(frame, frame_addr, 0);
1068 force_sig(TARGET_SIGSEGV);
66fb9763
FB		 1069 return 0;
1070}
1071
43fff238
FB		 1072#elif defined(TARGET_ARM)
1073
1074struct target_sigcontext {
992f48a0
BS		 1075 abi_ulong trap_no;
1076 abi_ulong error_code;
1077 abi_ulong oldmask;
1078 abi_ulong arm_r0;
1079 abi_ulong arm_r1;
1080 abi_ulong arm_r2;
1081 abi_ulong arm_r3;
1082 abi_ulong arm_r4;
1083 abi_ulong arm_r5;
1084 abi_ulong arm_r6;
1085 abi_ulong arm_r7;
1086 abi_ulong arm_r8;
1087 abi_ulong arm_r9;
1088 abi_ulong arm_r10;
1089 abi_ulong arm_fp;
1090 abi_ulong arm_ip;
1091 abi_ulong arm_sp;
1092 abi_ulong arm_lr;
1093 abi_ulong arm_pc;
1094 abi_ulong arm_cpsr;
1095 abi_ulong fault_address;
43fff238
FB		 1096};
1097
a745ec6d
PB		 1098struct target_ucontext_v1 {
1099 abi_ulong tuc_flags;
1100 abi_ulong tuc_link;
1101 target_stack_t tuc_stack;
1102 struct target_sigcontext tuc_mcontext;
1103 target_sigset_t tuc_sigmask; /* mask last for extensibility */
1104};
1105
1106struct target_ucontext_v2 {
992f48a0
BS		 1107 abi_ulong tuc_flags;
1108 abi_ulong tuc_link;
b8076a74
FB		 1109 target_stack_t tuc_stack;
1110 struct target_sigcontext tuc_mcontext;
1111 target_sigset_t tuc_sigmask; /* mask last for extensibility */
a745ec6d
PB		 1112 char __unused[128 - sizeof(sigset_t)];
1113 abi_ulong tuc_regspace[128] __attribute__((__aligned__(8)));
43fff238
FB		 1114};
1115
a8c33204 1116struct sigframe_v1
43fff238
FB		 1117{
1118 struct target_sigcontext sc;
992f48a0
BS		 1119 abi_ulong extramask[TARGET_NSIG_WORDS-1];
1120 abi_ulong retcode;
43fff238
FB		 1121};
1122
a8c33204
PB		 1123struct sigframe_v2
1124{
1125 struct target_ucontext_v2 uc;
1126 abi_ulong retcode;
1127};
1128
a745ec6d 1129struct rt_sigframe_v1
43fff238 1130{
f8b0aa25
FB		 1131 abi_ulong pinfo;
1132 abi_ulong puc;
43fff238 1133 struct target_siginfo info;
a745ec6d
PB		 1134 struct target_ucontext_v1 uc;
1135 abi_ulong retcode;
1136};
1137
1138struct rt_sigframe_v2
1139{
1140 struct target_siginfo info;
1141 struct target_ucontext_v2 uc;
992f48a0 1142 abi_ulong retcode;
43fff238
FB		 1143};
1144
1145#define TARGET_CONFIG_CPU_32 1
1146
1147/*
1148 * For ARM syscalls, we encode the syscall number into the instruction.
1149 */
1150#define SWI_SYS_SIGRETURN (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE))
1151#define SWI_SYS_RT_SIGRETURN (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE))
1152
1153/*
1154 * For Thumb syscalls, we pass the syscall number via r7. We therefore
1155 * need two 16-bit instructions.
1156 */
1157#define SWI_THUMB_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn))
1158#define SWI_THUMB_RT_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn))
1159
992f48a0 1160static const abi_ulong retcodes[4] = {
43fff238
FB		 1161 SWI_SYS_SIGRETURN, SWI_THUMB_SIGRETURN,
1162 SWI_SYS_RT_SIGRETURN, SWI_THUMB_RT_SIGRETURN
1163};
1164
1165
43fff238
FB		 1166#define __get_user_error(x,p,e) __get_user(x, p)
1167
1168static inline int valid_user_regs(CPUState *regs)
1169{
1170 return 1;
1171}
1172
a8c33204 1173static void
43fff238 1174setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
f8b0aa25 1175 CPUState *env, abi_ulong mask)
43fff238 1176{
a8c33204
PB		 1177 __put_user(env->regs[0], &sc->arm_r0);
1178 __put_user(env->regs[1], &sc->arm_r1);
1179 __put_user(env->regs[2], &sc->arm_r2);
1180 __put_user(env->regs[3], &sc->arm_r3);
1181 __put_user(env->regs[4], &sc->arm_r4);
1182 __put_user(env->regs[5], &sc->arm_r5);
1183 __put_user(env->regs[6], &sc->arm_r6);
1184 __put_user(env->regs[7], &sc->arm_r7);
1185 __put_user(env->regs[8], &sc->arm_r8);
1186 __put_user(env->regs[9], &sc->arm_r9);
1187 __put_user(env->regs[10], &sc->arm_r10);
1188 __put_user(env->regs[11], &sc->arm_fp);
1189 __put_user(env->regs[12], &sc->arm_ip);
1190 __put_user(env->regs[13], &sc->arm_sp);
1191 __put_user(env->regs[14], &sc->arm_lr);
1192 __put_user(env->regs[15], &sc->arm_pc);
43fff238 1193#ifdef TARGET_CONFIG_CPU_32
a8c33204 1194 __put_user(cpsr_read(env), &sc->arm_cpsr);
43fff238
FB		 1195#endif
1196
a8c33204
PB		 1197 __put_user(/* current->thread.trap_no */ 0, &sc->trap_no);
1198 __put_user(/* current->thread.error_code */ 0, &sc->error_code);
1199 __put_user(/* current->thread.address */ 0, &sc->fault_address);
1200 __put_user(mask, &sc->oldmask);
43fff238
FB		 1201}
1202
579a97f7 1203static inline abi_ulong
624f7979 1204get_sigframe(struct target_sigaction *ka, CPUState *regs, int framesize)
43fff238
FB		 1205{
1206 unsigned long sp = regs->regs[13];
1207
43fff238
FB		 1208 /*
1209 * This is the X/Open sanctioned signal stack switching.
1210 */
624f7979 1211 if ((ka->sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp))
a04e134a 1212 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
43fff238
FB		 1213 /*
1214 * ATPCS B01 mandates 8-byte alignment
1215 */
579a97f7 1216 return (sp - framesize) & ~7;
43fff238
FB		 1217}
1218
1219static int
624f7979 1220setup_return(CPUState *env, struct target_sigaction *ka,
f8b0aa25 1221 abi_ulong *rc, abi_ulong frame_addr, int usig, abi_ulong rc_addr)
43fff238 1222{
624f7979 1223 abi_ulong handler = ka->_sa_handler;
992f48a0 1224 abi_ulong retcode;
75b680e5 1225 int thumb = handler & 1;
43fff238 1226
624f7979
PB		 1227 if (ka->sa_flags & TARGET_SA_RESTORER) {
1228 retcode = ka->sa_restorer;
43fff238
FB		 1229 } else {
1230 unsigned int idx = thumb;
1231
624f7979 1232 if (ka->sa_flags & TARGET_SA_SIGINFO)
43fff238
FB		 1233 idx += 2;
1234
1235 if (__put_user(retcodes[idx], rc))
1236 return 1;
1237#if 0
992f48a0
BS		 1238 flush_icache_range((abi_ulong)rc,
1239 (abi_ulong)(rc + 1));
43fff238 1240#endif
f8b0aa25 1241 retcode = rc_addr + thumb;
43fff238
FB		 1242 }
1243
1244 env->regs[0] = usig;
f8b0aa25 1245 env->regs[13] = frame_addr;
43fff238
FB		 1246 env->regs[14] = retcode;
1247 env->regs[15] = handler & (thumb ? ~1 : ~3);
75b680e5 1248 env->thumb = thumb;
43fff238 1249
b5ff1b31 1250#if 0
43fff238
FB		 1251#ifdef TARGET_CONFIG_CPU_32
1252 env->cpsr = cpsr;
b5ff1b31 1253#endif
43fff238
FB		 1254#endif
1255
1256 return 0;
1257}
1258
a8c33204
PB		 1259static void setup_sigframe_v2(struct target_ucontext_v2 *uc,
1260 target_sigset_t *set, CPUState *env)
1261{
1262 struct target_sigaltstack stack;
1263 int i;
1264
1265 /* Clear all the bits of the ucontext we don't use. */
1266 memset(uc, 0, offsetof(struct target_ucontext_v2, tuc_mcontext));
1267
1268 memset(&stack, 0, sizeof(stack));
1269 __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp);
1270 __put_user(target_sigaltstack_used.ss_size, &stack.ss_size);
1271 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags);
1272 memcpy(&uc->tuc_stack, &stack, sizeof(stack));
1273
1274 setup_sigcontext(&uc->tuc_mcontext, env, set->sig[0]);
1275 /* FIXME: Save coprocessor signal frame. */
1276 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1277 __put_user(set->sig[i], &uc->tuc_sigmask.sig[i]);
1278 }
1279}
1280
579a97f7 1281/* compare linux/arch/arm/kernel/signal.c:setup_frame() */
624f7979 1282static void setup_frame_v1(int usig, struct target_sigaction *ka,
a8c33204 1283 target_sigset_t *set, CPUState *regs)
43fff238 1284{
a8c33204 1285 struct sigframe_v1 *frame;
579a97f7 1286 abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
a8c33204 1287 int i;
43fff238 1288
579a97f7
FB		 1289 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1290 return;
1291
a8c33204 1292 setup_sigcontext(&frame->sc, regs, set->sig[0]);
43fff238 1293
9231944d
FB		 1294 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1295 if (__put_user(set->sig[i], &frame->extramask[i - 1]))
579a97f7 1296 goto end;
43fff238
FB		 1297 }
1298
a8c33204
PB		 1299 setup_return(regs, ka, &frame->retcode, frame_addr, usig,
1300 frame_addr + offsetof(struct sigframe_v1, retcode));
579a97f7
FB		 1301
1302end:
1303 unlock_user_struct(frame, frame_addr, 1);
a8c33204
PB		 1304}
1305
624f7979 1306static void setup_frame_v2(int usig, struct target_sigaction *ka,
a8c33204
PB		 1307 target_sigset_t *set, CPUState *regs)
1308{
1309 struct sigframe_v2 *frame;
1310 abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
1311
1312 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1313 return;
1314
1315 setup_sigframe_v2(&frame->uc, set, regs);
1316
1317 setup_return(regs, ka, &frame->retcode, frame_addr, usig,
1318 frame_addr + offsetof(struct sigframe_v2, retcode));
1319
1320 unlock_user_struct(frame, frame_addr, 1);
1321}
1322
624f7979 1323static void setup_frame(int usig, struct target_sigaction *ka,
a8c33204
PB		 1324 target_sigset_t *set, CPUState *regs)
1325{
1326 if (get_osversion() >= 0x020612) {
1327 setup_frame_v2(usig, ka, set, regs);
1328 } else {
1329 setup_frame_v1(usig, ka, set, regs);
1330 }
43fff238
FB		 1331}
1332
579a97f7 1333/* compare linux/arch/arm/kernel/signal.c:setup_rt_frame() */
624f7979 1334static void setup_rt_frame_v1(int usig, struct target_sigaction *ka,
a745ec6d
PB		 1335 target_siginfo_t *info,
1336 target_sigset_t *set, CPUState *env)
43fff238 1337{
a745ec6d 1338 struct rt_sigframe_v1 *frame;
579a97f7 1339 abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
a04e134a 1340 struct target_sigaltstack stack;
a8c33204 1341 int i;
f8b0aa25 1342 abi_ulong info_addr, uc_addr;
43fff238 1343
579a97f7 1344 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
edf779ff
FB		 1345 return /* 1 */;
1346
a745ec6d 1347 info_addr = frame_addr + offsetof(struct rt_sigframe_v1, info);
a8c33204 1348 __put_user(info_addr, &frame->pinfo);
a745ec6d 1349 uc_addr = frame_addr + offsetof(struct rt_sigframe_v1, uc);
a8c33204
PB		 1350 __put_user(uc_addr, &frame->puc);
1351 copy_siginfo_to_user(&frame->info, info);
43fff238
FB		 1352
1353 /* Clear all the bits of the ucontext we don't use. */
a745ec6d 1354 memset(&frame->uc, 0, offsetof(struct target_ucontext_v1, tuc_mcontext));
43fff238 1355
a04e134a
TS		 1356 memset(&stack, 0, sizeof(stack));
1357 __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp);
1358 __put_user(target_sigaltstack_used.ss_size, &stack.ss_size);
1359 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags);
775b58d8 1360 memcpy(&frame->uc.tuc_stack, &stack, sizeof(stack));
a04e134a 1361
a8c33204 1362 setup_sigcontext(&frame->uc.tuc_mcontext, env, set->sig[0]);
9231944d 1363 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
b8076a74 1364 if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
579a97f7 1365 goto end;
9231944d 1366 }
43fff238 1367
a8c33204
PB		 1368 setup_return(env, ka, &frame->retcode, frame_addr, usig,
1369 frame_addr + offsetof(struct rt_sigframe_v1, retcode));
a745ec6d 1370
a8c33204
PB		 1371 env->regs[1] = info_addr;
1372 env->regs[2] = uc_addr;
a745ec6d
PB		 1373
1374end:
1375 unlock_user_struct(frame, frame_addr, 1);
a745ec6d
PB		 1376}
1377
624f7979 1378static void setup_rt_frame_v2(int usig, struct target_sigaction *ka,
a745ec6d
PB		 1379 target_siginfo_t *info,
1380 target_sigset_t *set, CPUState *env)
1381{
1382 struct rt_sigframe_v2 *frame;
1383 abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
a745ec6d
PB		 1384 abi_ulong info_addr, uc_addr;
1385
1386 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1387 return /* 1 */;
1388
1389 info_addr = frame_addr + offsetof(struct rt_sigframe_v2, info);
1390 uc_addr = frame_addr + offsetof(struct rt_sigframe_v2, uc);
a8c33204 1391 copy_siginfo_to_user(&frame->info, info);
a745ec6d 1392
a8c33204 1393 setup_sigframe_v2(&frame->uc, set, env);
a745ec6d 1394
a8c33204
PB		 1395 setup_return(env, ka, &frame->retcode, frame_addr, usig,
1396 frame_addr + offsetof(struct rt_sigframe_v2, retcode));
a745ec6d 1397
a8c33204
PB		 1398 env->regs[1] = info_addr;
1399 env->regs[2] = uc_addr;
43fff238 1400
579a97f7 1401 unlock_user_struct(frame, frame_addr, 1);
43fff238
FB		 1402}
1403
624f7979 1404static void setup_rt_frame(int usig, struct target_sigaction *ka,
a745ec6d
PB		 1405 target_siginfo_t *info,
1406 target_sigset_t *set, CPUState *env)
1407{
1408 if (get_osversion() >= 0x020612) {
1409 setup_rt_frame_v2(usig, ka, info, set, env);
1410 } else {
1411 setup_rt_frame_v1(usig, ka, info, set, env);
1412 }
1413}
1414
43fff238
FB		 1415static int
1416restore_sigcontext(CPUState *env, struct target_sigcontext *sc)
1417{
1418 int err = 0;
b5ff1b31 1419 uint32_t cpsr;
43fff238
FB		 1420
1421 __get_user_error(env->regs[0], &sc->arm_r0, err);
1422 __get_user_error(env->regs[1], &sc->arm_r1, err);
1423 __get_user_error(env->regs[2], &sc->arm_r2, err);
1424 __get_user_error(env->regs[3], &sc->arm_r3, err);
1425 __get_user_error(env->regs[4], &sc->arm_r4, err);
1426 __get_user_error(env->regs[5], &sc->arm_r5, err);
1427 __get_user_error(env->regs[6], &sc->arm_r6, err);
1428 __get_user_error(env->regs[7], &sc->arm_r7, err);
1429 __get_user_error(env->regs[8], &sc->arm_r8, err);
1430 __get_user_error(env->regs[9], &sc->arm_r9, err);
1431 __get_user_error(env->regs[10], &sc->arm_r10, err);
1432 __get_user_error(env->regs[11], &sc->arm_fp, err);
1433 __get_user_error(env->regs[12], &sc->arm_ip, err);
1434 __get_user_error(env->regs[13], &sc->arm_sp, err);
1435 __get_user_error(env->regs[14], &sc->arm_lr, err);
1436 __get_user_error(env->regs[15], &sc->arm_pc, err);
1437#ifdef TARGET_CONFIG_CPU_32
b5ff1b31 1438 __get_user_error(cpsr, &sc->arm_cpsr, err);
75b680e5 1439 cpsr_write(env, cpsr, CPSR_USER | CPSR_EXEC);
43fff238
FB		 1440#endif
1441
1442 err |= !valid_user_regs(env);
1443
1444 return err;
1445}
1446
dc7eea67 1447static long do_sigreturn_v1(CPUState *env)
43fff238 1448{
f8b0aa25 1449 abi_ulong frame_addr;
a8c33204 1450 struct sigframe_v1 *frame;
43fff238
FB		 1451 target_sigset_t set;
1452 sigset_t host_set;
9231944d 1453 int i;
43fff238
FB		 1454
1455 /*
1456 * Since we stacked the signal on a 64-bit boundary,
1457 * then 'sp' should be word aligned here. If it's
1458 * not, then the user is trying to mess with us.
1459 */
1460 if (env->regs[13] & 7)
1461 goto badframe;
1462
f8b0aa25
FB		 1463 frame_addr = env->regs[13];
1464 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1465 goto badframe;
43fff238 1466
9231944d
FB		 1467 if (__get_user(set.sig[0], &frame->sc.oldmask))
1468 goto badframe;
1469 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1470 if (__get_user(set.sig[i], &frame->extramask[i - 1]))
1471 goto badframe;
1472 }
43fff238 1473
9231944d 1474 target_to_host_sigset_internal(&host_set, &set);
43fff238
FB		 1475 sigprocmask(SIG_SETMASK, &host_set, NULL);
1476
1477 if (restore_sigcontext(env, &frame->sc))
1478 goto badframe;
1479
1480#if 0
1481 /* Send SIGTRAP if we're single-stepping */
1482 if (ptrace_cancel_bpt(current))
1483 send_sig(SIGTRAP, current, 1);
1484#endif
f8b0aa25
FB		 1485 unlock_user_struct(frame, frame_addr, 0);
1486 return env->regs[0];
43fff238
FB		 1487
1488badframe:
f8b0aa25 1489 unlock_user_struct(frame, frame_addr, 0);
43fff238
FB		 1490 force_sig(SIGSEGV /* , current */);
1491 return 0;
1492}
1493
a8c33204
PB		 1494static int do_sigframe_return_v2(CPUState *env, target_ulong frame_addr,
1495 struct target_ucontext_v2 *uc)
1496{
1497 sigset_t host_set;
1498
1499 target_to_host_sigset(&host_set, &uc->tuc_sigmask);
1500 sigprocmask(SIG_SETMASK, &host_set, NULL);
1501
1502 if (restore_sigcontext(env, &uc->tuc_mcontext))
1503 return 1;
1504
1505 if (do_sigaltstack(frame_addr + offsetof(struct target_ucontext_v2, tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT)
1506 return 1;
1507
1508#if 0
1509 /* Send SIGTRAP if we're single-stepping */
1510 if (ptrace_cancel_bpt(current))
1511 send_sig(SIGTRAP, current, 1);
1512#endif
1513
1514 return 0;
1515}
1516
dc7eea67 1517static long do_sigreturn_v2(CPUState *env)
a8c33204
PB		 1518{
1519 abi_ulong frame_addr;
1520 struct sigframe_v2 *frame;
1521
1522 /*
1523 * Since we stacked the signal on a 64-bit boundary,
1524 * then 'sp' should be word aligned here. If it's
1525 * not, then the user is trying to mess with us.
1526 */
1527 if (env->regs[13] & 7)
1528 goto badframe;
1529
1530 frame_addr = env->regs[13];
1531 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1532 goto badframe;
1533
1534 if (do_sigframe_return_v2(env, frame_addr, &frame->uc))
1535 goto badframe;
1536
1537 unlock_user_struct(frame, frame_addr, 0);
1538 return env->regs[0];
1539
1540badframe:
1541 unlock_user_struct(frame, frame_addr, 0);
1542 force_sig(SIGSEGV /* , current */);
1543 return 0;
1544}
1545
1546long do_sigreturn(CPUState *env)
1547{
1548 if (get_osversion() >= 0x020612) {
1549 return do_sigreturn_v2(env);
1550 } else {
1551 return do_sigreturn_v1(env);
1552 }
1553}
1554
dc7eea67 1555static long do_rt_sigreturn_v1(CPUState *env)
43fff238 1556{
f8b0aa25 1557 abi_ulong frame_addr;
a745ec6d
PB		 1558 struct rt_sigframe_v1 *frame;
1559 sigset_t host_set;
1560
1561 /*
1562 * Since we stacked the signal on a 64-bit boundary,
1563 * then 'sp' should be word aligned here. If it's
1564 * not, then the user is trying to mess with us.
1565 */
1566 if (env->regs[13] & 7)
1567 goto badframe;
1568
1569 frame_addr = env->regs[13];
1570 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1571 goto badframe;
1572
1573 target_to_host_sigset(&host_set, &frame->uc.tuc_sigmask);
1574 sigprocmask(SIG_SETMASK, &host_set, NULL);
1575
1576 if (restore_sigcontext(env, &frame->uc.tuc_mcontext))
1577 goto badframe;
1578
1579 if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe_v1, uc.tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT)
1580 goto badframe;
1581
1582#if 0
1583 /* Send SIGTRAP if we're single-stepping */
1584 if (ptrace_cancel_bpt(current))
1585 send_sig(SIGTRAP, current, 1);
1586#endif
1587 unlock_user_struct(frame, frame_addr, 0);
1588 return env->regs[0];
1589
1590badframe:
1591 unlock_user_struct(frame, frame_addr, 0);
1592 force_sig(SIGSEGV /* , current */);
1593 return 0;
1594}
1595
dc7eea67 1596static long do_rt_sigreturn_v2(CPUState *env)
a745ec6d
PB		 1597{
1598 abi_ulong frame_addr;
1599 struct rt_sigframe_v2 *frame;
43fff238
FB		 1600
1601 /*
1602 * Since we stacked the signal on a 64-bit boundary,
1603 * then 'sp' should be word aligned here. If it's
1604 * not, then the user is trying to mess with us.
1605 */
1606 if (env->regs[13] & 7)
1607 goto badframe;
1608
f8b0aa25
FB		 1609 frame_addr = env->regs[13];
1610 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1611 goto badframe;
43fff238 1612
a8c33204
PB		 1613 if (do_sigframe_return_v2(env, frame_addr, &frame->uc))
1614 goto badframe;
a04e134a 1615
f8b0aa25 1616 unlock_user_struct(frame, frame_addr, 0);
43fff238
FB		 1617 return env->regs[0];
1618
1619badframe:
f8b0aa25 1620 unlock_user_struct(frame, frame_addr, 0);
43fff238
FB		 1621 force_sig(SIGSEGV /* , current */);
1622 return 0;
1623}
1624
a745ec6d
PB		 1625long do_rt_sigreturn(CPUState *env)
1626{
1627 if (get_osversion() >= 0x020612) {
1628 return do_rt_sigreturn_v2(env);
1629 } else {
1630 return do_rt_sigreturn_v1(env);
1631 }
1632}
1633
6d5e216d 1634#elif defined(TARGET_SPARC)
80a9d035 1635
6d5e216d
FB		 1636#define __SUNOS_MAXWIN 31
1637
1638/* This is what SunOS does, so shall I. */
1639struct target_sigcontext {
992f48a0 1640 abi_ulong sigc_onstack; /* state to restore */
6d5e216d 1641
992f48a0
BS		 1642 abi_ulong sigc_mask; /* sigmask to restore */
1643 abi_ulong sigc_sp; /* stack pointer */
1644 abi_ulong sigc_pc; /* program counter */
1645 abi_ulong sigc_npc; /* next program counter */
1646 abi_ulong sigc_psr; /* for condition codes etc */
1647 abi_ulong sigc_g1; /* User uses these two registers */
1648 abi_ulong sigc_o0; /* within the trampoline code. */
6d5e216d
FB		 1649
1650 /* Now comes information regarding the users window set
1651 * at the time of the signal.
1652 */
992f48a0 1653 abi_ulong sigc_oswins; /* outstanding windows */
6d5e216d
FB		 1654
1655 /* stack ptrs for each regwin buf */
1656 char *sigc_spbuf[__SUNOS_MAXWIN];
1657
1658 /* Windows to restore after signal */
1659 struct {
992f48a0
BS		 1660 abi_ulong locals[8];
1661 abi_ulong ins[8];
6d5e216d
FB		 1662 } sigc_wbuf[__SUNOS_MAXWIN];
1663};
1664/* A Sparc stack frame */
1665struct sparc_stackf {
992f48a0
BS		 1666 abi_ulong locals[8];
1667 abi_ulong ins[6];
6d5e216d 1668 struct sparc_stackf *fp;
992f48a0 1669 abi_ulong callers_pc;
6d5e216d 1670 char *structptr;
992f48a0
BS		 1671 abi_ulong xargs[6];
1672 abi_ulong xxargs[1];
6d5e216d
FB		 1673};
1674
1675typedef struct {
1676 struct {
992f48a0
BS		 1677 abi_ulong psr;
1678 abi_ulong pc;
1679 abi_ulong npc;
1680 abi_ulong y;
1681 abi_ulong u_regs[16]; /* globals and ins */
6d5e216d
FB		 1682 } si_regs;
1683 int si_mask;
1684} __siginfo_t;
1685
1686typedef struct {
1687 unsigned long si_float_regs [32];
1688 unsigned long si_fsr;
1689 unsigned long si_fpqdepth;
1690 struct {
1691 unsigned long *insn_addr;
1692 unsigned long insn;
1693 } si_fpqueue [16];
74ccb34e 1694} qemu_siginfo_fpu_t;
6d5e216d
FB		 1695
1696
1697struct target_signal_frame {
1698 struct sparc_stackf ss;
1699 __siginfo_t info;
f8b0aa25 1700 abi_ulong fpu_save;
992f48a0
BS		 1701 abi_ulong insns[2] __attribute__ ((aligned (8)));
1702 abi_ulong extramask[TARGET_NSIG_WORDS - 1];
1703 abi_ulong extra_size; /* Should be 0 */
74ccb34e 1704 qemu_siginfo_fpu_t fpu_state;
6d5e216d
FB		 1705};
1706struct target_rt_signal_frame {
1707 struct sparc_stackf ss;
1708 siginfo_t info;
992f48a0 1709 abi_ulong regs[20];
6d5e216d 1710 sigset_t mask;
f8b0aa25 1711 abi_ulong fpu_save;
6d5e216d
FB		 1712 unsigned int insns[2];
1713 stack_t stack;
1714 unsigned int extra_size; /* Should be 0 */
74ccb34e 1715 qemu_siginfo_fpu_t fpu_state;
6d5e216d
FB		 1716};
1717
e80cfcfc
FB		 1718#define UREG_O0 16
1719#define UREG_O6 22
1720#define UREG_I0 0
1721#define UREG_I1 1
1722#define UREG_I2 2
5bfb56b2
BS		 1723#define UREG_I3 3
1724#define UREG_I4 4
1725#define UREG_I5 5
e80cfcfc
FB		 1726#define UREG_I6 6
1727#define UREG_I7 7
1728#define UREG_L0 8
6d5e216d
FB		 1729#define UREG_FP UREG_I6
1730#define UREG_SP UREG_O6
1731
624f7979 1732static inline abi_ulong get_sigframe(struct target_sigaction *sa,
459a4017 1733 CPUState *env, unsigned long framesize)
6d5e216d 1734{
459a4017 1735 abi_ulong sp;
6d5e216d
FB		 1736
1737 sp = env->regwptr[UREG_FP];
6d5e216d
FB		 1738
1739 /* This is the X/Open sanctioned signal stack switching. */
624f7979 1740 if (sa->sa_flags & TARGET_SA_ONSTACK) {
a04e134a
TS		 1741 if (!on_sig_stack(sp)
1742 && !((target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size) & 7))
1743 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
6d5e216d 1744 }
459a4017 1745 return sp - framesize;
6d5e216d
FB		 1746}
1747
1748static int
992f48a0 1749setup___siginfo(__siginfo_t *si, CPUState *env, abi_ulong mask)
6d5e216d
FB		 1750{
1751 int err = 0, i;
1752
6d5e216d 1753 err |= __put_user(env->psr, &si->si_regs.psr);
6d5e216d
FB		 1754 err |= __put_user(env->pc, &si->si_regs.pc);
1755 err |= __put_user(env->npc, &si->si_regs.npc);
1756 err |= __put_user(env->y, &si->si_regs.y);
a315a145 1757 for (i=0; i < 8; i++) {
6d5e216d
FB		 1758 err |= __put_user(env->gregs[i], &si->si_regs.u_regs[i]);
1759 }
a315a145 1760 for (i=0; i < 8; i++) {
e80cfcfc 1761 err |= __put_user(env->regwptr[UREG_I0 + i], &si->si_regs.u_regs[i+8]);
6d5e216d 1762 }
6d5e216d
FB		 1763 err |= __put_user(mask, &si->si_mask);
1764 return err;
1765}
e80cfcfc 1766
80a9d035 1767#if 0
6d5e216d
FB		 1768static int
1769setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
1770 CPUState *env, unsigned long mask)
1771{
1772 int err = 0;
1773
1774 err |= __put_user(mask, &sc->sigc_mask);
1775 err |= __put_user(env->regwptr[UREG_SP], &sc->sigc_sp);
1776 err |= __put_user(env->pc, &sc->sigc_pc);
1777 err |= __put_user(env->npc, &sc->sigc_npc);
1778 err |= __put_user(env->psr, &sc->sigc_psr);
1779 err |= __put_user(env->gregs[1], &sc->sigc_g1);
1780 err |= __put_user(env->regwptr[UREG_O0], &sc->sigc_o0);
1781
1782 return err;
1783}
80a9d035 1784#endif
6d5e216d
FB		 1785#define NF_ALIGNEDSZ (((sizeof(struct target_signal_frame) + 7) & (~7)))
1786
624f7979 1787static void setup_frame(int sig, struct target_sigaction *ka,
6d5e216d
FB		 1788 target_sigset_t *set, CPUState *env)
1789{
459a4017 1790 abi_ulong sf_addr;
6d5e216d
FB		 1791 struct target_signal_frame *sf;
1792 int sigframe_size, err, i;
1793
1794 /* 1. Make sure everything is clean */
1795 //synchronize_user_stack();
1796
1797 sigframe_size = NF_ALIGNEDSZ;
459a4017 1798 sf_addr = get_sigframe(ka, env, sigframe_size);
6d5e216d 1799
459a4017
FB		 1800 sf = lock_user(VERIFY_WRITE, sf_addr,
1801 sizeof(struct target_signal_frame), 0);
1802 if (!sf)
1803 goto sigsegv;
1804
e80cfcfc 1805 //fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
6d5e216d
FB		 1806#if 0
1807 if (invalid_frame_pointer(sf, sigframe_size))
1808 goto sigill_and_return;
1809#endif
1810 /* 2. Save the current process state */
1811 err = setup___siginfo(&sf->info, env, set->sig[0]);
1812 err |= __put_user(0, &sf->extra_size);
1813
1814 //err |= save_fpu_state(regs, &sf->fpu_state);
1815 //err |= __put_user(&sf->fpu_state, &sf->fpu_save);
1816
1817 err |= __put_user(set->sig[0], &sf->info.si_mask);
1818 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
1819 err |= __put_user(set->sig[i + 1], &sf->extramask[i]);
1820 }
1821
a315a145 1822 for (i = 0; i < 8; i++) {
e80cfcfc 1823 err |= __put_user(env->regwptr[i + UREG_L0], &sf->ss.locals[i]);
6d5e216d 1824 }
a315a145 1825 for (i = 0; i < 8; i++) {
e80cfcfc 1826 err |= __put_user(env->regwptr[i + UREG_I0], &sf->ss.ins[i]);
6d5e216d 1827 }
6d5e216d
FB		 1828 if (err)
1829 goto sigsegv;
1830
1831 /* 3. signal handler back-trampoline and parameters */
459a4017 1832 env->regwptr[UREG_FP] = sf_addr;
6d5e216d 1833 env->regwptr[UREG_I0] = sig;
459a4017
FB		 1834 env->regwptr[UREG_I1] = sf_addr +
1835 offsetof(struct target_signal_frame, info);
1836 env->regwptr[UREG_I2] = sf_addr +
1837 offsetof(struct target_signal_frame, info);
6d5e216d
FB		 1838
1839 /* 4. signal handler */
624f7979 1840 env->pc = ka->_sa_handler;
6d5e216d
FB		 1841 env->npc = (env->pc + 4);
1842 /* 5. return to kernel instructions */
624f7979
PB		 1843 if (ka->sa_restorer)
1844 env->regwptr[UREG_I7] = ka->sa_restorer;
6d5e216d 1845 else {
775b58d8 1846 uint32_t val32;
459a4017
FB		 1847
1848 env->regwptr[UREG_I7] = sf_addr +
1849 offsetof(struct target_signal_frame, insns) - 2 * 4;
6d5e216d
FB		 1850
1851 /* mov __NR_sigreturn, %g1 */
775b58d8
FB		 1852 val32 = 0x821020d8;
1853 err |= __put_user(val32, &sf->insns[0]);
6d5e216d
FB		 1854
1855 /* t 0x10 */
775b58d8
FB		 1856 val32 = 0x91d02010;
1857 err |= __put_user(val32, &sf->insns[1]);
6d5e216d
FB		 1858 if (err)
1859 goto sigsegv;
1860
1861 /* Flush instruction space. */
1862 //flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
80a9d035 1863 // tb_flush(env);
6d5e216d 1864 }
459a4017 1865 unlock_user(sf, sf_addr, sizeof(struct target_signal_frame));
6d5e216d 1866 return;
459a4017
FB		 1867#if 0
1868sigill_and_return:
6d5e216d 1869 force_sig(TARGET_SIGILL);
459a4017 1870#endif
6d5e216d 1871sigsegv:
e80cfcfc 1872 //fprintf(stderr, "force_sig\n");
459a4017 1873 unlock_user(sf, sf_addr, sizeof(struct target_signal_frame));
6d5e216d
FB		 1874 force_sig(TARGET_SIGSEGV);
1875}
1876static inline int
74ccb34e 1877restore_fpu_state(CPUState *env, qemu_siginfo_fpu_t *fpu)
6d5e216d
FB		 1878{
1879 int err;
1880#if 0
1881#ifdef CONFIG_SMP
1882 if (current->flags & PF_USEDFPU)
1883 regs->psr &= ~PSR_EF;
1884#else
1885 if (current == last_task_used_math) {
1886 last_task_used_math = 0;
1887 regs->psr &= ~PSR_EF;
1888 }
1889#endif
1890 current->used_math = 1;
1891 current->flags &= ~PF_USEDFPU;
1892#endif
1893#if 0
1894 if (verify_area (VERIFY_READ, fpu, sizeof(*fpu)))
1895 return -EFAULT;
1896#endif
1897
fafffaef
FB		 1898#if 0
1899 /* XXX: incorrect */
6d5e216d
FB		 1900 err = __copy_from_user(&env->fpr[0], &fpu->si_float_regs[0],
1901 (sizeof(unsigned long) * 32));
fafffaef 1902#endif
6d5e216d
FB		 1903 err |= __get_user(env->fsr, &fpu->si_fsr);
1904#if 0
1905 err |= __get_user(current->thread.fpqdepth, &fpu->si_fpqdepth);
1906 if (current->thread.fpqdepth != 0)
1907 err |= __copy_from_user(&current->thread.fpqueue[0],
1908 &fpu->si_fpqueue[0],
1909 ((sizeof(unsigned long) +
1910 (sizeof(unsigned long *)))*16));
1911#endif
1912 return err;
1913}
1914
1915
624f7979 1916static void setup_rt_frame(int sig, struct target_sigaction *ka,
6d5e216d
FB		 1917 target_siginfo_t *info,
1918 target_sigset_t *set, CPUState *env)
1919{
1920 fprintf(stderr, "setup_rt_frame: not implemented\n");
1921}
1922
1923long do_sigreturn(CPUState *env)
1924{
f8b0aa25 1925 abi_ulong sf_addr;
6d5e216d 1926 struct target_signal_frame *sf;
e80cfcfc 1927 uint32_t up_psr, pc, npc;
6d5e216d 1928 target_sigset_t set;
e80cfcfc 1929 sigset_t host_set;
f8b0aa25 1930 abi_ulong fpu_save_addr;
e80cfcfc 1931 int err, i;
6d5e216d 1932
f8b0aa25
FB		 1933 sf_addr = env->regwptr[UREG_FP];
1934 if (!lock_user_struct(VERIFY_READ, sf, sf_addr, 1))
1935 goto segv_and_exit;
80a9d035 1936#if 0
e80cfcfc
FB		 1937 fprintf(stderr, "sigreturn\n");
1938 fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
80a9d035 1939#endif
e80cfcfc 1940 //cpu_dump_state(env, stderr, fprintf, 0);
6d5e216d
FB		 1941
1942 /* 1. Make sure we are not getting garbage from the user */
6d5e216d 1943
f8b0aa25 1944 if (sf_addr & 3)
6d5e216d
FB		 1945 goto segv_and_exit;
1946
1947 err = __get_user(pc, &sf->info.si_regs.pc);
1948 err |= __get_user(npc, &sf->info.si_regs.npc);
1949
6d5e216d
FB		 1950 if ((pc | npc) & 3)
1951 goto segv_and_exit;
1952
1953 /* 2. Restore the state */
e80cfcfc
FB		 1954 err |= __get_user(up_psr, &sf->info.si_regs.psr);
1955
6d5e216d 1956 /* User can only change condition codes and FPU enabling in %psr. */
a315a145
FB		 1957 env->psr = (up_psr & (PSR_ICC /* | PSR_EF */))
1958 | (env->psr & ~(PSR_ICC /* | PSR_EF */));
1959
1960 env->pc = pc;
1961 env->npc = npc;
e80cfcfc 1962 err |= __get_user(env->y, &sf->info.si_regs.y);
a315a145 1963 for (i=0; i < 8; i++) {
e80cfcfc
FB		 1964 err |= __get_user(env->gregs[i], &sf->info.si_regs.u_regs[i]);
1965 }
a315a145 1966 for (i=0; i < 8; i++) {
e80cfcfc
FB		 1967 err |= __get_user(env->regwptr[i + UREG_I0], &sf->info.si_regs.u_regs[i+8]);
1968 }
6d5e216d 1969
f8b0aa25 1970 err |= __get_user(fpu_save_addr, &sf->fpu_save);
6d5e216d 1971
e80cfcfc
FB		 1972 //if (fpu_save)
1973 // err |= restore_fpu_state(env, fpu_save);
6d5e216d
FB		 1974
1975 /* This is pretty much atomic, no amount locking would prevent
1976 * the races which exist anyways.
1977 */
1978 err |= __get_user(set.sig[0], &sf->info.si_mask);
e80cfcfc
FB		 1979 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1980 err |= (__get_user(set.sig[i], &sf->extramask[i - 1]));
1981 }
1982
1983 target_to_host_sigset_internal(&host_set, &set);
1984 sigprocmask(SIG_SETMASK, &host_set, NULL);
6d5e216d
FB		 1985
1986 if (err)
1987 goto segv_and_exit;
f8b0aa25 1988 unlock_user_struct(sf, sf_addr, 0);
6d5e216d
FB		 1989 return env->regwptr[0];
1990
1991segv_and_exit:
f8b0aa25 1992 unlock_user_struct(sf, sf_addr, 0);
6d5e216d
FB		 1993 force_sig(TARGET_SIGSEGV);
1994}
1995
1996long do_rt_sigreturn(CPUState *env)
1997{
1998 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
f8b0aa25 1999 return -TARGET_ENOSYS;
6d5e216d
FB		 2000}
2001
459a4017 2002#if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
5bfb56b2
BS		 2003#define MC_TSTATE 0
2004#define MC_PC 1
2005#define MC_NPC 2
2006#define MC_Y 3
2007#define MC_G1 4
2008#define MC_G2 5
2009#define MC_G3 6
2010#define MC_G4 7
2011#define MC_G5 8
2012#define MC_G6 9
2013#define MC_G7 10
2014#define MC_O0 11
2015#define MC_O1 12
2016#define MC_O2 13
2017#define MC_O3 14
2018#define MC_O4 15
2019#define MC_O5 16
2020#define MC_O6 17
2021#define MC_O7 18
2022#define MC_NGREG 19
2023
992f48a0 2024typedef abi_ulong target_mc_greg_t;
5bfb56b2
BS		 2025typedef target_mc_greg_t target_mc_gregset_t[MC_NGREG];
2026
2027struct target_mc_fq {
992f48a0 2028 abi_ulong *mcfq_addr;
5bfb56b2
BS		 2029 uint32_t mcfq_insn;
2030};
2031
2032struct target_mc_fpu {
2033 union {
2034 uint32_t sregs[32];
2035 uint64_t dregs[32];
2036 //uint128_t qregs[16];
2037 } mcfpu_fregs;
992f48a0
BS		 2038 abi_ulong mcfpu_fsr;
2039 abi_ulong mcfpu_fprs;
2040 abi_ulong mcfpu_gsr;
5bfb56b2
BS		 2041 struct target_mc_fq *mcfpu_fq;
2042 unsigned char mcfpu_qcnt;
2043 unsigned char mcfpu_qentsz;
2044 unsigned char mcfpu_enab;
2045};
2046typedef struct target_mc_fpu target_mc_fpu_t;
2047
2048typedef struct {
2049 target_mc_gregset_t mc_gregs;
2050 target_mc_greg_t mc_fp;
2051 target_mc_greg_t mc_i7;
2052 target_mc_fpu_t mc_fpregs;
2053} target_mcontext_t;
2054
2055struct target_ucontext {
2056 struct target_ucontext *uc_link;
992f48a0 2057 abi_ulong uc_flags;
5bfb56b2
BS		 2058 target_sigset_t uc_sigmask;
2059 target_mcontext_t uc_mcontext;
2060};
2061
2062/* A V9 register window */
2063struct target_reg_window {
992f48a0
BS		 2064 abi_ulong locals[8];
2065 abi_ulong ins[8];
5bfb56b2
BS		 2066};
2067
2068#define TARGET_STACK_BIAS 2047
2069
2070/* {set, get}context() needed for 64-bit SparcLinux userland. */
2071void sparc64_set_context(CPUSPARCState *env)
2072{
459a4017
FB		 2073 abi_ulong ucp_addr;
2074 struct target_ucontext *ucp;
5bfb56b2 2075 target_mc_gregset_t *grp;
992f48a0 2076 abi_ulong pc, npc, tstate;
459a4017 2077 abi_ulong fp, i7, w_addr;
5bfb56b2
BS		 2078 unsigned char fenab;
2079 int err;
2080 unsigned int i;
5bfb56b2 2081
459a4017
FB		 2082 ucp_addr = env->regwptr[UREG_I0];
2083 if (!lock_user_struct(VERIFY_READ, ucp, ucp_addr, 1))
2084 goto do_sigsegv;
5bfb56b2 2085 grp = &ucp->uc_mcontext.mc_gregs;
579a97f7
FB		 2086 err = __get_user(pc, &((*grp)[MC_PC]));
2087 err |= __get_user(npc, &((*grp)[MC_NPC]));
5bfb56b2
BS		 2088 if (err || ((pc | npc) & 3))
2089 goto do_sigsegv;
2090 if (env->regwptr[UREG_I1]) {
2091 target_sigset_t target_set;
2092 sigset_t set;
2093
2094 if (TARGET_NSIG_WORDS == 1) {
579a97f7 2095 if (__get_user(target_set.sig[0], &ucp->uc_sigmask.sig[0]))
5bfb56b2
BS		 2096 goto do_sigsegv;
2097 } else {
459a4017
FB		 2098 abi_ulong *src, *dst;
2099 src = ucp->uc_sigmask.sig;
2100 dst = target_set.sig;
992f48a0 2101 for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong);
5bfb56b2 2102 i++, dst++, src++)
459a4017 2103 err |= __get_user(*dst, src);
5bfb56b2
BS		 2104 if (err)
2105 goto do_sigsegv;
2106 }
2107 target_to_host_sigset_internal(&set, &target_set);
2108 sigprocmask(SIG_SETMASK, &set, NULL);
2109 }
2110 env->pc = pc;
2111 env->npc = npc;
579a97f7
FB		 2112 err |= __get_user(env->y, &((*grp)[MC_Y]));
2113 err |= __get_user(tstate, &((*grp)[MC_TSTATE]));
5bfb56b2
BS		 2114 env->asi = (tstate >> 24) & 0xff;
2115 PUT_CCR(env, tstate >> 32);
2116 PUT_CWP64(env, tstate & 0x1f);
579a97f7
FB		 2117 err |= __get_user(env->gregs[1], (&(*grp)[MC_G1]));
2118 err |= __get_user(env->gregs[2], (&(*grp)[MC_G2]));
2119 err |= __get_user(env->gregs[3], (&(*grp)[MC_G3]));
2120 err |= __get_user(env->gregs[4], (&(*grp)[MC_G4]));
2121 err |= __get_user(env->gregs[5], (&(*grp)[MC_G5]));
2122 err |= __get_user(env->gregs[6], (&(*grp)[MC_G6]));
2123 err |= __get_user(env->gregs[7], (&(*grp)[MC_G7]));
2124 err |= __get_user(env->regwptr[UREG_I0], (&(*grp)[MC_O0]));
2125 err |= __get_user(env->regwptr[UREG_I1], (&(*grp)[MC_O1]));
2126 err |= __get_user(env->regwptr[UREG_I2], (&(*grp)[MC_O2]));
2127 err |= __get_user(env->regwptr[UREG_I3], (&(*grp)[MC_O3]));
2128 err |= __get_user(env->regwptr[UREG_I4], (&(*grp)[MC_O4]));
2129 err |= __get_user(env->regwptr[UREG_I5], (&(*grp)[MC_O5]));
2130 err |= __get_user(env->regwptr[UREG_I6], (&(*grp)[MC_O6]));
2131 err |= __get_user(env->regwptr[UREG_I7], (&(*grp)[MC_O7]));
2132
2133 err |= __get_user(fp, &(ucp->uc_mcontext.mc_fp));
2134 err |= __get_user(i7, &(ucp->uc_mcontext.mc_i7));
579a97f7 2135
459a4017
FB		 2136 w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
2137 if (put_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]),
2138 abi_ulong) != 0)
2139 goto do_sigsegv;
2140 if (put_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]),
2141 abi_ulong) != 0)
2142 goto do_sigsegv;
579a97f7
FB		 2143 err |= __get_user(fenab, &(ucp->uc_mcontext.mc_fpregs.mcfpu_enab));
2144 err |= __get_user(env->fprs, &(ucp->uc_mcontext.mc_fpregs.mcfpu_fprs));
459a4017
FB		 2145 {
2146 uint32_t *src, *dst;
2147 src = ucp->uc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2148 dst = env->fpr;
2149 /* XXX: check that the CPU storage is the same as user context */
2150 for (i = 0; i < 64; i++, dst++, src++)
2151 err |= __get_user(*dst, src);
2152 }
579a97f7
FB		 2153 err |= __get_user(env->fsr,
2154 &(ucp->uc_mcontext.mc_fpregs.mcfpu_fsr));
2155 err |= __get_user(env->gsr,
2156 &(ucp->uc_mcontext.mc_fpregs.mcfpu_gsr));
5bfb56b2
BS		 2157 if (err)
2158 goto do_sigsegv;
459a4017 2159 unlock_user_struct(ucp, ucp_addr, 0);
5bfb56b2
BS		 2160 return;
2161 do_sigsegv:
459a4017 2162 unlock_user_struct(ucp, ucp_addr, 0);
5bfb56b2
BS		 2163 force_sig(SIGSEGV);
2164}
2165
2166void sparc64_get_context(CPUSPARCState *env)
2167{
459a4017
FB		 2168 abi_ulong ucp_addr;
2169 struct target_ucontext *ucp;
5bfb56b2
BS		 2170 target_mc_gregset_t *grp;
2171 target_mcontext_t *mcp;
459a4017 2172 abi_ulong fp, i7, w_addr;
5bfb56b2
BS		 2173 int err;
2174 unsigned int i;
5bfb56b2
BS		 2175 target_sigset_t target_set;
2176 sigset_t set;
2177
459a4017
FB		 2178 ucp_addr = env->regwptr[UREG_I0];
2179 if (!lock_user_struct(VERIFY_WRITE, ucp, ucp_addr, 0))
2180 goto do_sigsegv;
2181
5bfb56b2
BS		 2182 mcp = &ucp->uc_mcontext;
2183 grp = &mcp->mc_gregs;
2184
2185 /* Skip over the trap instruction, first. */
2186 env->pc = env->npc;
2187 env->npc += 4;
2188
2189 err = 0;
2190
2191 sigprocmask(0, NULL, &set);
2192 host_to_target_sigset_internal(&target_set, &set);
459a4017 2193 if (TARGET_NSIG_WORDS == 1) {
579a97f7
FB		 2194 err |= __put_user(target_set.sig[0],
2195 (abi_ulong *)&ucp->uc_sigmask);
459a4017
FB		 2196 } else {
2197 abi_ulong *src, *dst;
2198 src = target_set.sig;
2199 dst = ucp->uc_sigmask.sig;
992f48a0 2200 for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong);
5bfb56b2 2201 i++, dst++, src++)
459a4017 2202 err |= __put_user(*src, dst);
5bfb56b2
BS		 2203 if (err)
2204 goto do_sigsegv;
2205 }
2206
459a4017
FB		 2207 /* XXX: tstate must be saved properly */
2208 // err |= __put_user(env->tstate, &((*grp)[MC_TSTATE]));
579a97f7
FB		 2209 err |= __put_user(env->pc, &((*grp)[MC_PC]));
2210 err |= __put_user(env->npc, &((*grp)[MC_NPC]));
2211 err |= __put_user(env->y, &((*grp)[MC_Y]));
2212 err |= __put_user(env->gregs[1], &((*grp)[MC_G1]));
2213 err |= __put_user(env->gregs[2], &((*grp)[MC_G2]));
2214 err |= __put_user(env->gregs[3], &((*grp)[MC_G3]));
2215 err |= __put_user(env->gregs[4], &((*grp)[MC_G4]));
2216 err |= __put_user(env->gregs[5], &((*grp)[MC_G5]));
2217 err |= __put_user(env->gregs[6], &((*grp)[MC_G6]));
2218 err |= __put_user(env->gregs[7], &((*grp)[MC_G7]));
2219 err |= __put_user(env->regwptr[UREG_I0], &((*grp)[MC_O0]));
2220 err |= __put_user(env->regwptr[UREG_I1], &((*grp)[MC_O1]));
2221 err |= __put_user(env->regwptr[UREG_I2], &((*grp)[MC_O2]));
2222 err |= __put_user(env->regwptr[UREG_I3], &((*grp)[MC_O3]));
2223 err |= __put_user(env->regwptr[UREG_I4], &((*grp)[MC_O4]));
2224 err |= __put_user(env->regwptr[UREG_I5], &((*grp)[MC_O5]));
2225 err |= __put_user(env->regwptr[UREG_I6], &((*grp)[MC_O6]));
2226 err |= __put_user(env->regwptr[UREG_I7], &((*grp)[MC_O7]));
2227
459a4017
FB		 2228 w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
2229 fp = i7 = 0;
2230 if (get_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]),
2231 abi_ulong) != 0)
2232 goto do_sigsegv;
2233 if (get_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]),
2234 abi_ulong) != 0)
2235 goto do_sigsegv;
579a97f7
FB		 2236 err |= __put_user(fp, &(mcp->mc_fp));
2237 err |= __put_user(i7, &(mcp->mc_i7));
5bfb56b2 2238
459a4017
FB		 2239 {
2240 uint32_t *src, *dst;
2241 src = env->fpr;
2242 dst = ucp->uc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2243 /* XXX: check that the CPU storage is the same as user context */
2244 for (i = 0; i < 64; i++, dst++, src++)
2245 err |= __put_user(*src, dst);
2246 }
579a97f7
FB		 2247 err |= __put_user(env->fsr, &(mcp->mc_fpregs.mcfpu_fsr));
2248 err |= __put_user(env->gsr, &(mcp->mc_fpregs.mcfpu_gsr));
2249 err |= __put_user(env->fprs, &(mcp->mc_fpregs.mcfpu_fprs));
5bfb56b2
BS		 2250
2251 if (err)
2252 goto do_sigsegv;
459a4017 2253 unlock_user_struct(ucp, ucp_addr, 1);
5bfb56b2
BS		 2254 return;
2255 do_sigsegv:
459a4017 2256 unlock_user_struct(ucp, ucp_addr, 1);
5bfb56b2
BS		 2257 force_sig(SIGSEGV);
2258}
2259#endif
d26bc211 2260#elif defined(TARGET_ABI_MIPSN64)
540635ba
TS		 2261
2262# warning signal handling not implemented
2263
624f7979 2264static void setup_frame(int sig, struct target_sigaction *ka,
540635ba
TS		 2265 target_sigset_t *set, CPUState *env)
2266{
2267 fprintf(stderr, "setup_frame: not implemented\n");
2268}
2269
624f7979 2270static void setup_rt_frame(int sig, struct target_sigaction *ka,
540635ba
TS		 2271 target_siginfo_t *info,
2272 target_sigset_t *set, CPUState *env)
2273{
2274 fprintf(stderr, "setup_rt_frame: not implemented\n");
2275}
2276
2277long do_sigreturn(CPUState *env)
2278{
2279 fprintf(stderr, "do_sigreturn: not implemented\n");
f8b0aa25 2280 return -TARGET_ENOSYS;
540635ba
TS		 2281}
2282
2283long do_rt_sigreturn(CPUState *env)
2284{
2285 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
f8b0aa25 2286 return -TARGET_ENOSYS;
540635ba
TS		 2287}
2288
d26bc211 2289#elif defined(TARGET_ABI_MIPSN32)
540635ba
TS		 2290
2291# warning signal handling not implemented
2292
624f7979 2293static void setup_frame(int sig, struct target_sigaction *ka,
540635ba
TS		 2294 target_sigset_t *set, CPUState *env)
2295{
2296 fprintf(stderr, "setup_frame: not implemented\n");
2297}
2298
624f7979 2299static void setup_rt_frame(int sig, struct target_sigaction *ka,
540635ba
TS		 2300 target_siginfo_t *info,
2301 target_sigset_t *set, CPUState *env)
2302{
2303 fprintf(stderr, "setup_rt_frame: not implemented\n");
2304}
2305
2306long do_sigreturn(CPUState *env)
2307{
2308 fprintf(stderr, "do_sigreturn: not implemented\n");
f8b0aa25 2309 return -TARGET_ENOSYS;
540635ba
TS		 2310}
2311
2312long do_rt_sigreturn(CPUState *env)
2313{
2314 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
f8b0aa25 2315 return -TARGET_ENOSYS;
540635ba
TS		 2316}
2317
d26bc211 2318#elif defined(TARGET_ABI_MIPSO32)
106ec879
FB		 2319
2320struct target_sigcontext {
2321 uint32_t sc_regmask; /* Unused */
2322 uint32_t sc_status;
2323 uint64_t sc_pc;
2324 uint64_t sc_regs[32];
2325 uint64_t sc_fpregs[32];
2326 uint32_t sc_ownedfp; /* Unused */
2327 uint32_t sc_fpc_csr;
2328 uint32_t sc_fpc_eir; /* Unused */
2329 uint32_t sc_used_math;
2330 uint32_t sc_dsp; /* dsp status, was sc_ssflags */
94c5495d 2331 uint32_t pad0;
106ec879
FB		 2332 uint64_t sc_mdhi;
2333 uint64_t sc_mdlo;
2334 target_ulong sc_hi1; /* Was sc_cause */
2335 target_ulong sc_lo1; /* Was sc_badvaddr */
2336 target_ulong sc_hi2; /* Was sc_sigset[4] */
2337 target_ulong sc_lo2;
2338 target_ulong sc_hi3;
2339 target_ulong sc_lo3;
2340};
2341
2342struct sigframe {
2343 uint32_t sf_ass[4]; /* argument save space for o32 */
2344 uint32_t sf_code[2]; /* signal trampoline */
2345 struct target_sigcontext sf_sc;
2346 target_sigset_t sf_mask;
2347};
2348
0b1bcb00
PB		 2349struct target_ucontext {
2350 target_ulong uc_flags;
2351 target_ulong uc_link;
2352 target_stack_t uc_stack;
94c5495d 2353 target_ulong pad0;
0b1bcb00
PB		 2354 struct target_sigcontext uc_mcontext;
2355 target_sigset_t uc_sigmask;
2356};
2357
2358struct target_rt_sigframe {
2359 uint32_t rs_ass[4]; /* argument save space for o32 */
2360 uint32_t rs_code[2]; /* signal trampoline */
2361 struct target_siginfo rs_info;
2362 struct target_ucontext rs_uc;
2363};
2364
106ec879
FB		 2365/* Install trampoline to jump back from signal handler */
2366static inline int install_sigtramp(unsigned int *tramp, unsigned int syscall)
2367{
2368 int err;
2369
2370 /*
2371 * Set up the return code ...
2372 *
2373 * li v0, __NR__foo_sigreturn
2374 * syscall
2375 */
2376
2377 err = __put_user(0x24020000 + syscall, tramp + 0);
2378 err |= __put_user(0x0000000c , tramp + 1);
2379 /* flush_cache_sigtramp((unsigned long) tramp); */
2380 return err;
2381}
2382
2383static inline int
2384setup_sigcontext(CPUState *regs, struct target_sigcontext *sc)
2385{
2386 int err = 0;
2387
b5dc7732 2388 err |= __put_user(regs->active_tc.PC, &sc->sc_pc);
106ec879 2389
b5dc7732
TS		 2390#define save_gp_reg(i) do { \
2391 err |= __put_user(regs->active_tc.gpr[i], &sc->sc_regs[i]); \
106ec879
FB		 2392 } while(0)
2393 __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2);
2394 save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
2395 save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
2396 save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
2397 save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
2398 save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
2399 save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
2400 save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
2401 save_gp_reg(31);
388bb21a 2402#undef save_gp_reg
106ec879 2403
b5dc7732
TS		 2404 err |= __put_user(regs->active_tc.HI[0], &sc->sc_mdhi);
2405 err |= __put_user(regs->active_tc.LO[0], &sc->sc_mdlo);
106ec879
FB		 2406
2407 /* Not used yet, but might be useful if we ever have DSP suppport */
2408#if 0
2409 if (cpu_has_dsp) {
2410 err |= __put_user(mfhi1(), &sc->sc_hi1);
2411 err |= __put_user(mflo1(), &sc->sc_lo1);
2412 err |= __put_user(mfhi2(), &sc->sc_hi2);
2413 err |= __put_user(mflo2(), &sc->sc_lo2);
2414 err |= __put_user(mfhi3(), &sc->sc_hi3);
2415 err |= __put_user(mflo3(), &sc->sc_lo3);
2416 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
2417 }
2418 /* same with 64 bit */
388bb21a 2419#ifdef CONFIG_64BIT
106ec879
FB		 2420 err |= __put_user(regs->hi, &sc->sc_hi[0]);
2421 err |= __put_user(regs->lo, &sc->sc_lo[0]);
2422 if (cpu_has_dsp) {
2423 err |= __put_user(mfhi1(), &sc->sc_hi[1]);
2424 err |= __put_user(mflo1(), &sc->sc_lo[1]);
2425 err |= __put_user(mfhi2(), &sc->sc_hi[2]);
2426 err |= __put_user(mflo2(), &sc->sc_lo[2]);
2427 err |= __put_user(mfhi3(), &sc->sc_hi[3]);
2428 err |= __put_user(mflo3(), &sc->sc_lo[3]);
2429 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
2430 }
388bb21a
TS		 2431#endif
2432#endif
106ec879 2433
388bb21a 2434#if 0
106ec879
FB		 2435 err |= __put_user(!!used_math(), &sc->sc_used_math);
2436
2437 if (!used_math())
2438 goto out;
2439
2440 /*
2441 * Save FPU state to signal context. Signal handler will "inherit"
2442 * current FPU state.
2443 */
2444 preempt_disable();
2445
2446 if (!is_fpu_owner()) {
2447 own_fpu();
2448 restore_fp(current);
2449 }
2450 err |= save_fp_context(sc);
2451
2452 preempt_enable();
2453 out:
2454#endif
2455 return err;
2456}
2457
2458static inline int
2459restore_sigcontext(CPUState *regs, struct target_sigcontext *sc)
2460{
2461 int err = 0;
2462
2463 err |= __get_user(regs->CP0_EPC, &sc->sc_pc);
2464
b5dc7732
TS		 2465 err |= __get_user(regs->active_tc.HI[0], &sc->sc_mdhi);
2466 err |= __get_user(regs->active_tc.LO[0], &sc->sc_mdlo);
106ec879 2467
ead9360e 2468#define restore_gp_reg(i) do { \
b5dc7732 2469 err |= __get_user(regs->active_tc.gpr[i], &sc->sc_regs[i]); \
106ec879
FB		 2470 } while(0)
2471 restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
2472 restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
2473 restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
2474 restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
2475 restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
2476 restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
2477 restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
2478 restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
2479 restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
2480 restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
2481 restore_gp_reg(31);
388bb21a 2482#undef restore_gp_reg
106ec879
FB		 2483
2484#if 0
2485 if (cpu_has_dsp) {
2486 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
2487 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
2488 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
2489 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
2490 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
2491 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
2492 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
2493 }
388bb21a 2494#ifdef CONFIG_64BIT
106ec879
FB		 2495 err |= __get_user(regs->hi, &sc->sc_hi[0]);
2496 err |= __get_user(regs->lo, &sc->sc_lo[0]);
2497 if (cpu_has_dsp) {
2498 err |= __get_user(treg, &sc->sc_hi[1]); mthi1(treg);
2499 err |= __get_user(treg, &sc->sc_lo[1]); mthi1(treg);
2500 err |= __get_user(treg, &sc->sc_hi[2]); mthi2(treg);
2501 err |= __get_user(treg, &sc->sc_lo[2]); mthi2(treg);
2502 err |= __get_user(treg, &sc->sc_hi[3]); mthi3(treg);
2503 err |= __get_user(treg, &sc->sc_lo[3]); mthi3(treg);
2504 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
2505 }
388bb21a 2506#endif
106ec879
FB		 2507
2508 err |= __get_user(used_math, &sc->sc_used_math);
2509 conditional_used_math(used_math);
2510
2511 preempt_disable();
2512
2513 if (used_math()) {
2514 /* restore fpu context if we have used it before */
2515 own_fpu();
2516 err |= restore_fp_context(sc);
2517 } else {
2518 /* signal handler may have used FPU. Give it up. */
2519 lose_fpu();
2520 }
2521
2522 preempt_enable();
2523#endif
2524 return err;
2525}
2526/*
2527 * Determine which stack to use..
2528 */
579a97f7 2529static inline abi_ulong
624f7979 2530get_sigframe(struct target_sigaction *ka, CPUState *regs, size_t frame_size)
106ec879
FB		 2531{
2532 unsigned long sp;
2533
2534 /* Default to using normal stack */
b5dc7732 2535 sp = regs->active_tc.gpr[29];
106ec879
FB		 2536
2537 /*
2538 * FPU emulator may have it's own trampoline active just
2539 * above the user stack, 16-bytes before the next lowest
2540 * 16 byte boundary. Try to avoid trashing it.
2541 */
2542 sp -= 32;
2543
106ec879 2544 /* This is the X/Open sanctioned signal stack switching. */
624f7979 2545 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) {
a04e134a
TS		 2546 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
2547 }
106ec879 2548
579a97f7 2549 return (sp - frame_size) & ~7;
106ec879
FB		 2550}
2551
579a97f7 2552/* compare linux/arch/mips/kernel/signal.c:setup_frame() */
624f7979 2553static void setup_frame(int sig, struct target_sigaction * ka,
579a97f7 2554 target_sigset_t *set, CPUState *regs)
106ec879
FB		 2555{
2556 struct sigframe *frame;
579a97f7 2557 abi_ulong frame_addr;
106ec879
FB		 2558 int i;
2559
579a97f7
FB		 2560 frame_addr = get_sigframe(ka, regs, sizeof(*frame));
2561 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
106ec879
FB		 2562 goto give_sigsegv;
2563
2564 install_sigtramp(frame->sf_code, TARGET_NR_sigreturn);
2565
2566 if(setup_sigcontext(regs, &frame->sf_sc))
2567 goto give_sigsegv;
2568
2569 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2570 if(__put_user(set->sig[i], &frame->sf_mask.sig[i]))
2571 goto give_sigsegv;
2572 }
2573
2574 /*
2575 * Arguments to signal handler:
2576 *
2577 * a0 = signal number
2578 * a1 = 0 (should be cause)
2579 * a2 = pointer to struct sigcontext
2580 *
2581 * $25 and PC point to the signal handler, $29 points to the
2582 * struct sigframe.
2583 */
b5dc7732
TS		 2584 regs->active_tc.gpr[ 4] = sig;
2585 regs->active_tc.gpr[ 5] = 0;
2586 regs->active_tc.gpr[ 6] = frame_addr + offsetof(struct sigframe, sf_sc);
2587 regs->active_tc.gpr[29] = frame_addr;
2588 regs->active_tc.gpr[31] = frame_addr + offsetof(struct sigframe, sf_code);
106ec879
FB		 2589 /* The original kernel code sets CP0_EPC to the handler
2590 * since it returns to userland using eret
2591 * we cannot do this here, and we must set PC directly */
b5dc7732 2592 regs->active_tc.PC = regs->active_tc.gpr[25] = ka->_sa_handler;
579a97f7 2593 unlock_user_struct(frame, frame_addr, 1);
106ec879
FB		 2594 return;
2595
2596give_sigsegv:
579a97f7 2597 unlock_user_struct(frame, frame_addr, 1);
106ec879 2598 force_sig(TARGET_SIGSEGV/*, current*/);
5fafdf24 2599 return;
106ec879
FB		 2600}
2601
2602long do_sigreturn(CPUState *regs)
2603{
388bb21a 2604 struct sigframe *frame;
579a97f7 2605 abi_ulong frame_addr;
388bb21a
TS		 2606 sigset_t blocked;
2607 target_sigset_t target_set;
2608 int i;
106ec879
FB		 2609
2610#if defined(DEBUG_SIGNAL)
388bb21a 2611 fprintf(stderr, "do_sigreturn\n");
106ec879 2612#endif
b5dc7732 2613 frame_addr = regs->active_tc.gpr[29];
579a97f7 2614 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
106ec879
FB		 2615 goto badframe;
2616
388bb21a 2617 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
106ec879
FB		 2618 if(__get_user(target_set.sig[i], &frame->sf_mask.sig[i]))
2619 goto badframe;
388bb21a 2620 }
106ec879 2621
388bb21a
TS		 2622 target_to_host_sigset_internal(&blocked, &target_set);
2623 sigprocmask(SIG_SETMASK, &blocked, NULL);
106ec879 2624
388bb21a 2625 if (restore_sigcontext(regs, &frame->sf_sc))
106ec879
FB		 2626 goto badframe;
2627
2628#if 0
388bb21a
TS		 2629 /*
2630 * Don't let your children do this ...
2631 */
2632 __asm__ __volatile__(
106ec879
FB		 2633 "move\t$29, %0\n\t"
2634 "j\tsyscall_exit"
2635 :/* no outputs */
2636 :"r" (&regs));
388bb21a 2637 /* Unreached */
106ec879 2638#endif
3b46e624 2639
b5dc7732 2640 regs->active_tc.PC = regs->CP0_EPC;
388bb21a 2641 /* I am not sure this is right, but it seems to work
106ec879
FB		 2642 * maybe a problem with nested signals ? */
2643 regs->CP0_EPC = 0;
0b1bcb00 2644 return -TARGET_QEMU_ESIGRETURN;
106ec879
FB		 2645
2646badframe:
388bb21a
TS		 2647 force_sig(TARGET_SIGSEGV/*, current*/);
2648 return 0;
106ec879
FB		 2649}
2650
624f7979 2651static void setup_rt_frame(int sig, struct target_sigaction *ka,
106ec879
FB		 2652 target_siginfo_t *info,
2653 target_sigset_t *set, CPUState *env)
2654{
0b1bcb00
PB		 2655 struct target_rt_sigframe *frame;
2656 abi_ulong frame_addr;
2657 int i;
2658
2659 frame_addr = get_sigframe(ka, env, sizeof(*frame));
2660 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
2661 goto give_sigsegv;
2662
2663 install_sigtramp(frame->rs_code, TARGET_NR_rt_sigreturn);
2664
2665 copy_siginfo_to_user(&frame->rs_info, info);
2666
2667 __put_user(0, &frame->rs_uc.uc_flags);
2668 __put_user(0, &frame->rs_uc.uc_link);
2669 __put_user(target_sigaltstack_used.ss_sp, &frame->rs_uc.uc_stack.ss_sp);
2670 __put_user(target_sigaltstack_used.ss_size, &frame->rs_uc.uc_stack.ss_size);
2671 __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
2672 &frame->rs_uc.uc_stack.ss_flags);
2673
2674 setup_sigcontext(env, &frame->rs_uc.uc_mcontext);
2675
2676 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2677 __put_user(set->sig[i], &frame->rs_uc.uc_sigmask.sig[i]);
2678 }
2679
2680 /*
2681 * Arguments to signal handler:
2682 *
2683 * a0 = signal number
2684 * a1 = pointer to struct siginfo
2685 * a2 = pointer to struct ucontext
2686 *
2687 * $25 and PC point to the signal handler, $29 points to the
2688 * struct sigframe.
2689 */
2690 env->active_tc.gpr[ 4] = sig;
2691 env->active_tc.gpr[ 5] = frame_addr
2692 + offsetof(struct target_rt_sigframe, rs_info);
2693 env->active_tc.gpr[ 6] = frame_addr
2694 + offsetof(struct target_rt_sigframe, rs_uc);
2695 env->active_tc.gpr[29] = frame_addr;
2696 env->active_tc.gpr[31] = frame_addr
2697 + offsetof(struct target_rt_sigframe, rs_code);
2698 /* The original kernel code sets CP0_EPC to the handler
2699 * since it returns to userland using eret
2700 * we cannot do this here, and we must set PC directly */
2701 env->active_tc.PC = env->active_tc.gpr[25] = ka->_sa_handler;
2702 unlock_user_struct(frame, frame_addr, 1);
2703 return;
2704
2705give_sigsegv:
2706 unlock_user_struct(frame, frame_addr, 1);
2707 force_sig(TARGET_SIGSEGV/*, current*/);
2708 return;
106ec879
FB		 2709}
2710
2711long do_rt_sigreturn(CPUState *env)
2712{
0b1bcb00
PB		 2713 struct target_rt_sigframe *frame;
2714 abi_ulong frame_addr;
2715 sigset_t blocked;
2716
2717#if defined(DEBUG_SIGNAL)
2718 fprintf(stderr, "do_rt_sigreturn\n");
2719#endif
2720 frame_addr = env->active_tc.gpr[29];
2721 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
2722 goto badframe;
2723
2724 target_to_host_sigset(&blocked, &frame->rs_uc.uc_sigmask);
2725 sigprocmask(SIG_SETMASK, &blocked, NULL);
2726
2727 if (restore_sigcontext(env, &frame->rs_uc.uc_mcontext))
2728 goto badframe;
2729
2730 if (do_sigaltstack(frame_addr +
2731 offsetof(struct target_rt_sigframe, rs_uc.uc_stack),
2732 0, get_sp_from_cpustate(env)) == -EFAULT)
2733 goto badframe;
2734
2735 env->active_tc.PC = env->CP0_EPC;
2736 /* I am not sure this is right, but it seems to work
2737 * maybe a problem with nested signals ? */
2738 env->CP0_EPC = 0;
2739 return -TARGET_QEMU_ESIGRETURN;
2740
2741badframe:
2742 force_sig(TARGET_SIGSEGV/*, current*/);
2743 return 0;
106ec879 2744}
6d5e216d 2745
c3b5bc8a
TS		 2746#elif defined(TARGET_SH4)
2747
2748/*
2749 * code and data structures from linux kernel:
2750 * include/asm-sh/sigcontext.h
2751 * arch/sh/kernel/signal.c
2752 */
2753
2754struct target_sigcontext {
2755 target_ulong oldmask;
2756
2757 /* CPU registers */
2758 target_ulong sc_gregs[16];
2759 target_ulong sc_pc;
2760 target_ulong sc_pr;
2761 target_ulong sc_sr;
2762 target_ulong sc_gbr;
2763 target_ulong sc_mach;
2764 target_ulong sc_macl;
2765
2766 /* FPU registers */
2767 target_ulong sc_fpregs[16];
2768 target_ulong sc_xfpregs[16];
2769 unsigned int sc_fpscr;
2770 unsigned int sc_fpul;
2771 unsigned int sc_ownedfp;
2772};
2773
2774struct target_sigframe
2775{
2776 struct target_sigcontext sc;
2777 target_ulong extramask[TARGET_NSIG_WORDS-1];
2778 uint16_t retcode[3];
2779};
2780
2781
2782struct target_ucontext {
2783 target_ulong uc_flags;
2784 struct target_ucontext *uc_link;
2785 target_stack_t uc_stack;
2786 struct target_sigcontext uc_mcontext;
2787 target_sigset_t uc_sigmask; /* mask last for extensibility */
2788};
2789
2790struct target_rt_sigframe
2791{
2792 struct target_siginfo info;
2793 struct target_ucontext uc;
2794 uint16_t retcode[3];
2795};
2796
2797
2798#define MOVW(n) (0x9300|((n)-2)) /* Move mem word at PC+n to R3 */
2799#define TRAP_NOARG 0xc310 /* Syscall w/no args (NR in R3) SH3/4 */
2800
624f7979 2801static abi_ulong get_sigframe(struct target_sigaction *ka,
c3b5bc8a
TS		 2802 unsigned long sp, size_t frame_size)
2803{
624f7979 2804 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags(sp) == 0)) {
c3b5bc8a
TS		 2805 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
2806 }
2807
2808 return (sp - frame_size) & -8ul;
2809}
2810
2811static int setup_sigcontext(struct target_sigcontext *sc,
2812 CPUState *regs, unsigned long mask)
2813{
2814 int err = 0;
2815
2816#define COPY(x) err |= __put_user(regs->x, &sc->sc_##x)
2817 COPY(gregs[0]); COPY(gregs[1]);
2818 COPY(gregs[2]); COPY(gregs[3]);
2819 COPY(gregs[4]); COPY(gregs[5]);
2820 COPY(gregs[6]); COPY(gregs[7]);
2821 COPY(gregs[8]); COPY(gregs[9]);
2822 COPY(gregs[10]); COPY(gregs[11]);
2823 COPY(gregs[12]); COPY(gregs[13]);
2824 COPY(gregs[14]); COPY(gregs[15]);
2825 COPY(gbr); COPY(mach);
2826 COPY(macl); COPY(pr);
2827 COPY(sr); COPY(pc);
2828#undef COPY
2829
2830 /* todo: save FPU registers here */
2831
2832 /* non-iBCS2 extensions.. */
2833 err |= __put_user(mask, &sc->oldmask);
2834
2835 return err;
2836}
2837
c2764719 2838static int restore_sigcontext(CPUState *regs,
c3b5bc8a
TS		 2839 struct target_sigcontext *sc)
2840{
2841 unsigned int err = 0;
2842
2843#define COPY(x) err |= __get_user(regs->x, &sc->sc_##x)
2844 COPY(gregs[1]);
2845 COPY(gregs[2]); COPY(gregs[3]);
2846 COPY(gregs[4]); COPY(gregs[5]);
2847 COPY(gregs[6]); COPY(gregs[7]);
2848 COPY(gregs[8]); COPY(gregs[9]);
2849 COPY(gregs[10]); COPY(gregs[11]);
2850 COPY(gregs[12]); COPY(gregs[13]);
2851 COPY(gregs[14]); COPY(gregs[15]);
2852 COPY(gbr); COPY(mach);
2853 COPY(macl); COPY(pr);
2854 COPY(sr); COPY(pc);
2855#undef COPY
2856
2857 /* todo: restore FPU registers here */
2858
2859 regs->tra = -1; /* disable syscall checks */
2860 return err;
2861}
2862
624f7979 2863static void setup_frame(int sig, struct target_sigaction *ka,
c3b5bc8a
TS		 2864 target_sigset_t *set, CPUState *regs)
2865{
2866 struct target_sigframe *frame;
2867 abi_ulong frame_addr;
2868 int i;
2869 int err = 0;
2870 int signal;
2871
2872 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
2873 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
2874 goto give_sigsegv;
2875
2876 signal = current_exec_domain_sig(sig);
2877
2878 err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
2879
2880 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
2881 err |= __put_user(set->sig[i + 1], &frame->extramask[i]);
2882 }
2883
2884 /* Set up to return from userspace. If provided, use a stub
2885 already in userspace. */
624f7979
PB		 2886 if (ka->sa_flags & TARGET_SA_RESTORER) {
2887 regs->pr = (unsigned long) ka->sa_restorer;
c3b5bc8a
TS		 2888 } else {
2889 /* Generate return code (system call to sigreturn) */
2890 err |= __put_user(MOVW(2), &frame->retcode[0]);
2891 err |= __put_user(TRAP_NOARG, &frame->retcode[1]);
2892 err |= __put_user((TARGET_NR_sigreturn), &frame->retcode[2]);
2893 regs->pr = (unsigned long) frame->retcode;
2894 }
2895
2896 if (err)
2897 goto give_sigsegv;
2898
2899 /* Set up registers for signal handler */
2900 regs->gregs[15] = (unsigned long) frame;
2901 regs->gregs[4] = signal; /* Arg for signal handler */
2902 regs->gregs[5] = 0;
2903 regs->gregs[6] = (unsigned long) &frame->sc;
624f7979 2904 regs->pc = (unsigned long) ka->_sa_handler;
c3b5bc8a
TS		 2905
2906 unlock_user_struct(frame, frame_addr, 1);
2907 return;
2908
2909give_sigsegv:
2910 unlock_user_struct(frame, frame_addr, 1);
2911 force_sig(SIGSEGV);
2912}
2913
624f7979 2914static void setup_rt_frame(int sig, struct target_sigaction *ka,
c3b5bc8a
TS		 2915 target_siginfo_t *info,
2916 target_sigset_t *set, CPUState *regs)
2917{
2918 struct target_rt_sigframe *frame;
2919 abi_ulong frame_addr;
2920 int i;
2921 int err = 0;
2922 int signal;
2923
2924 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
2925 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
2926 goto give_sigsegv;
2927
2928 signal = current_exec_domain_sig(sig);
2929
2930 err |= copy_siginfo_to_user(&frame->info, info);
2931
2932 /* Create the ucontext. */
2933 err |= __put_user(0, &frame->uc.uc_flags);
2934 err |= __put_user(0, (unsigned long *)&frame->uc.uc_link);
526ccb7a 2935 err |= __put_user((unsigned long)target_sigaltstack_used.ss_sp,
c3b5bc8a
TS		 2936 &frame->uc.uc_stack.ss_sp);
2937 err |= __put_user(sas_ss_flags(regs->gregs[15]),
2938 &frame->uc.uc_stack.ss_flags);
2939 err |= __put_user(target_sigaltstack_used.ss_size,
2940 &frame->uc.uc_stack.ss_size);
2941 err |= setup_sigcontext(&frame->uc.uc_mcontext,
2942 regs, set->sig[0]);
2943 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2944 err |= __put_user(set->sig[i], &frame->uc.uc_sigmask.sig[i]);
2945 }
2946
2947 /* Set up to return from userspace. If provided, use a stub
2948 already in userspace. */
624f7979
PB		 2949 if (ka->sa_flags & TARGET_SA_RESTORER) {
2950 regs->pr = (unsigned long) ka->sa_restorer;
c3b5bc8a
TS		 2951 } else {
2952 /* Generate return code (system call to sigreturn) */
2953 err |= __put_user(MOVW(2), &frame->retcode[0]);
2954 err |= __put_user(TRAP_NOARG, &frame->retcode[1]);
2955 err |= __put_user((TARGET_NR_rt_sigreturn), &frame->retcode[2]);
2956 regs->pr = (unsigned long) frame->retcode;
2957 }
2958
2959 if (err)
2960 goto give_sigsegv;
2961
2962 /* Set up registers for signal handler */
2963 regs->gregs[15] = (unsigned long) frame;
2964 regs->gregs[4] = signal; /* Arg for signal handler */
2965 regs->gregs[5] = (unsigned long) &frame->info;
2966 regs->gregs[6] = (unsigned long) &frame->uc;
624f7979 2967 regs->pc = (unsigned long) ka->_sa_handler;
c3b5bc8a
TS		 2968
2969 unlock_user_struct(frame, frame_addr, 1);
2970 return;
2971
2972give_sigsegv:
2973 unlock_user_struct(frame, frame_addr, 1);
2974 force_sig(SIGSEGV);
2975}
2976
2977long do_sigreturn(CPUState *regs)
2978{
2979 struct target_sigframe *frame;
2980 abi_ulong frame_addr;
2981 sigset_t blocked;
2982 target_sigset_t target_set;
2983 int i;
2984 int err = 0;
2985
2986#if defined(DEBUG_SIGNAL)
2987 fprintf(stderr, "do_sigreturn\n");
2988#endif
2989 frame_addr = regs->gregs[15];
2990 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
2991 goto badframe;
2992
2993 err |= __get_user(target_set.sig[0], &frame->sc.oldmask);
2994 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
2995 err |= (__get_user(target_set.sig[i], &frame->extramask[i - 1]));
2996 }
2997
2998 if (err)
2999 goto badframe;
3000
3001 target_to_host_sigset_internal(&blocked, &target_set);
3002 sigprocmask(SIG_SETMASK, &blocked, NULL);
3003
3004 if (restore_sigcontext(regs, &frame->sc))
3005 goto badframe;
3006
3007 unlock_user_struct(frame, frame_addr, 0);
3008 return regs->gregs[0];
3009
3010badframe:
3011 unlock_user_struct(frame, frame_addr, 0);
3012 force_sig(TARGET_SIGSEGV);
3013 return 0;
3014}
3015
3016long do_rt_sigreturn(CPUState *regs)
3017{
3018 struct target_rt_sigframe *frame;
3019 abi_ulong frame_addr;
3020 sigset_t blocked;
3021
3022#if defined(DEBUG_SIGNAL)
3023 fprintf(stderr, "do_rt_sigreturn\n");
3024#endif
3025 frame_addr = regs->gregs[15];
3026 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
3027 goto badframe;
3028
3029 target_to_host_sigset(&blocked, &frame->uc.uc_sigmask);
3030 sigprocmask(SIG_SETMASK, &blocked, NULL);
3031
3032 if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
3033 goto badframe;
3034
3035 if (do_sigaltstack(frame_addr +
3036 offsetof(struct target_rt_sigframe, uc.uc_stack),
3037 0, get_sp_from_cpustate(regs)) == -EFAULT)
3038 goto badframe;
3039
3040 unlock_user_struct(frame, frame_addr, 0);
3041 return regs->gregs[0];
3042
3043badframe:
3044 unlock_user_struct(frame, frame_addr, 0);
3045 force_sig(TARGET_SIGSEGV);
3046 return 0;
3047}
b779e29e
EI		 3048#elif defined(TARGET_MICROBLAZE)
3049
3050struct target_sigcontext {
3051 struct target_pt_regs regs; /* needs to be first */
3052 uint32_t oldmask;
3053};
3054
3055/* Signal frames. */
3056struct target_signal_frame {
3057 struct target_sigcontext sc;
3058 uint32_t extramask[TARGET_NSIG_WORDS - 1];
3059 uint32_t tramp[2];
3060};
3061
3062struct rt_signal_frame {
3063 struct siginfo info;
3064 struct ucontext uc;
3065 uint32_t tramp[2];
3066};
3067
3068static void setup_sigcontext(struct target_sigcontext *sc, CPUState *env)
3069{
3070 __put_user(env->regs[0], &sc->regs.r0);
3071 __put_user(env->regs[1], &sc->regs.r1);
3072 __put_user(env->regs[2], &sc->regs.r2);
3073 __put_user(env->regs[3], &sc->regs.r3);
3074 __put_user(env->regs[4], &sc->regs.r4);
3075 __put_user(env->regs[5], &sc->regs.r5);
3076 __put_user(env->regs[6], &sc->regs.r6);
3077 __put_user(env->regs[7], &sc->regs.r7);
3078 __put_user(env->regs[8], &sc->regs.r8);
3079 __put_user(env->regs[9], &sc->regs.r9);
3080 __put_user(env->regs[10], &sc->regs.r10);
3081 __put_user(env->regs[11], &sc->regs.r11);
3082 __put_user(env->regs[12], &sc->regs.r12);
3083 __put_user(env->regs[13], &sc->regs.r13);
3084 __put_user(env->regs[14], &sc->regs.r14);
3085 __put_user(env->regs[15], &sc->regs.r15);
3086 __put_user(env->regs[16], &sc->regs.r16);
3087 __put_user(env->regs[17], &sc->regs.r17);
3088 __put_user(env->regs[18], &sc->regs.r18);
3089 __put_user(env->regs[19], &sc->regs.r19);
3090 __put_user(env->regs[20], &sc->regs.r20);
3091 __put_user(env->regs[21], &sc->regs.r21);
3092 __put_user(env->regs[22], &sc->regs.r22);
3093 __put_user(env->regs[23], &sc->regs.r23);
3094 __put_user(env->regs[24], &sc->regs.r24);
3095 __put_user(env->regs[25], &sc->regs.r25);
3096 __put_user(env->regs[26], &sc->regs.r26);
3097 __put_user(env->regs[27], &sc->regs.r27);
3098 __put_user(env->regs[28], &sc->regs.r28);
3099 __put_user(env->regs[29], &sc->regs.r29);
3100 __put_user(env->regs[30], &sc->regs.r30);
3101 __put_user(env->regs[31], &sc->regs.r31);
3102 __put_user(env->sregs[SR_PC], &sc->regs.pc);
3103}
3104
3105static void restore_sigcontext(struct target_sigcontext *sc, CPUState *env)
3106{
3107 __get_user(env->regs[0], &sc->regs.r0);
3108 __get_user(env->regs[1], &sc->regs.r1);
3109 __get_user(env->regs[2], &sc->regs.r2);
3110 __get_user(env->regs[3], &sc->regs.r3);
3111 __get_user(env->regs[4], &sc->regs.r4);
3112 __get_user(env->regs[5], &sc->regs.r5);
3113 __get_user(env->regs[6], &sc->regs.r6);
3114 __get_user(env->regs[7], &sc->regs.r7);
3115 __get_user(env->regs[8], &sc->regs.r8);
3116 __get_user(env->regs[9], &sc->regs.r9);
3117 __get_user(env->regs[10], &sc->regs.r10);
3118 __get_user(env->regs[11], &sc->regs.r11);
3119 __get_user(env->regs[12], &sc->regs.r12);
3120 __get_user(env->regs[13], &sc->regs.r13);
3121 __get_user(env->regs[14], &sc->regs.r14);
3122 __get_user(env->regs[15], &sc->regs.r15);
3123 __get_user(env->regs[16], &sc->regs.r16);
3124 __get_user(env->regs[17], &sc->regs.r17);
3125 __get_user(env->regs[18], &sc->regs.r18);
3126 __get_user(env->regs[19], &sc->regs.r19);
3127 __get_user(env->regs[20], &sc->regs.r20);
3128 __get_user(env->regs[21], &sc->regs.r21);
3129 __get_user(env->regs[22], &sc->regs.r22);
3130 __get_user(env->regs[23], &sc->regs.r23);
3131 __get_user(env->regs[24], &sc->regs.r24);
3132 __get_user(env->regs[25], &sc->regs.r25);
3133 __get_user(env->regs[26], &sc->regs.r26);
3134 __get_user(env->regs[27], &sc->regs.r27);
3135 __get_user(env->regs[28], &sc->regs.r28);
3136 __get_user(env->regs[29], &sc->regs.r29);
3137 __get_user(env->regs[30], &sc->regs.r30);
3138 __get_user(env->regs[31], &sc->regs.r31);
3139 __get_user(env->sregs[SR_PC], &sc->regs.pc);
3140}
3141
3142static abi_ulong get_sigframe(struct target_sigaction *ka,
3143 CPUState *env, int frame_size)
3144{
3145 abi_ulong sp = env->regs[1];
3146
3147 if ((ka->sa_flags & SA_ONSTACK) != 0 && !on_sig_stack(sp))
3148 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
3149
3150 return ((sp - frame_size) & -8UL);
3151}
3152
3153static void setup_frame(int sig, struct target_sigaction *ka,
3154 target_sigset_t *set, CPUState *env)
3155{
3156 struct target_signal_frame *frame;
3157 abi_ulong frame_addr;
3158 int err = 0;
3159 int i;
3160
3161 frame_addr = get_sigframe(ka, env, sizeof *frame);
3162 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3163 goto badframe;
3164
3165 /* Save the mask. */
3166 err |= __put_user(set->sig[0], &frame->sc.oldmask);
3167 if (err)
3168 goto badframe;
3169
3170 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3171 if (__put_user(set->sig[i], &frame->extramask[i - 1]))
3172 goto badframe;
3173 }
3174
3175 setup_sigcontext(&frame->sc, env);
3176
3177 /* Set up to return from userspace. If provided, use a stub
3178 already in userspace. */
3179 /* minus 8 is offset to cater for "rtsd r15,8" offset */
3180 if (ka->sa_flags & TARGET_SA_RESTORER) {
3181 env->regs[15] = ((unsigned long)ka->sa_restorer)-8;
3182 } else {
3183 uint32_t t;
3184 /* Note, these encodings are _big endian_! */
3185 /* addi r12, r0, __NR_sigreturn */
3186 t = 0x31800000UL | TARGET_NR_sigreturn;
3187 err |= __put_user(t, frame->tramp + 0);
3188 /* brki r14, 0x8 */
3189 t = 0xb9cc0008UL;
3190 err |= __put_user(t, frame->tramp + 1);
3191
3192 /* Return from sighandler will jump to the tramp.
3193 Negative 8 offset because return is rtsd r15, 8 */
3194 env->regs[15] = ((unsigned long)frame->tramp) - 8;
3195 }
3196
3197 if (err)
3198 goto badframe;
3199
3200 /* Set up registers for signal handler */
3201 env->regs[1] = (unsigned long) frame;
3202 /* Signal handler args: */
3203 env->regs[5] = sig; /* Arg 0: signum */
3204 env->regs[6] = (unsigned long) &frame->sc; /* arg 1: sigcontext */
3205
3206 /* Offset of 4 to handle microblaze rtid r14, 0 */
3207 env->sregs[SR_PC] = (unsigned long)ka->_sa_handler;
3208
3209 unlock_user_struct(frame, frame_addr, 1);
3210 return;
3211 badframe:
3212 unlock_user_struct(frame, frame_addr, 1);
3213 force_sig(TARGET_SIGSEGV);
3214}
3215
3216static void setup_rt_frame(int sig, struct target_sigaction *ka,
3217 target_siginfo_t *info,
3218 target_sigset_t *set, CPUState *env)
3219{
3220 fprintf(stderr, "Microblaze setup_rt_frame: not implemented\n");
3221}
3222
3223long do_sigreturn(CPUState *env)
3224{
3225 struct target_signal_frame *frame;
3226 abi_ulong frame_addr;
3227 target_sigset_t target_set;
3228 sigset_t set;
3229 int i;
3230
3231 frame_addr = env->regs[R_SP];
3232 /* Make sure the guest isn't playing games. */
3233 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
3234 goto badframe;
3235
3236 /* Restore blocked signals */
3237 if (__get_user(target_set.sig[0], &frame->sc.oldmask))
3238 goto badframe;
3239 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3240 if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
3241 goto badframe;
3242 }
3243 target_to_host_sigset_internal(&set, &target_set);
3244 sigprocmask(SIG_SETMASK, &set, NULL);
3245
3246 restore_sigcontext(&frame->sc, env);
3247 /* We got here through a sigreturn syscall, our path back is via an
3248 rtb insn so setup r14 for that. */
3249 env->regs[14] = env->sregs[SR_PC];
3250
3251 unlock_user_struct(frame, frame_addr, 0);
3252 return env->regs[10];
3253 badframe:
3254 unlock_user_struct(frame, frame_addr, 0);
3255 force_sig(TARGET_SIGSEGV);
3256}
3257
3258long do_rt_sigreturn(CPUState *env)
3259{
3260 fprintf(stderr, "Microblaze do_rt_sigreturn: not implemented\n");
3261 return -TARGET_ENOSYS;
3262}
3263
b6d3abda
EI		 3264#elif defined(TARGET_CRIS)
3265
3266struct target_sigcontext {
3267 struct target_pt_regs regs; /* needs to be first */
3268 uint32_t oldmask;
3269 uint32_t usp; /* usp before stacking this gunk on it */
3270};
3271
3272/* Signal frames. */
3273struct target_signal_frame {
3274 struct target_sigcontext sc;
3275 uint32_t extramask[TARGET_NSIG_WORDS - 1];
3276 uint8_t retcode[8]; /* Trampoline code. */
3277};
3278
3279struct rt_signal_frame {
3280 struct siginfo *pinfo;
3281 void *puc;
3282 struct siginfo info;
3283 struct ucontext uc;
3284 uint8_t retcode[8]; /* Trampoline code. */
3285};
3286
3287static void setup_sigcontext(struct target_sigcontext *sc, CPUState *env)
3288{
9664d928
EI		 3289 __put_user(env->regs[0], &sc->regs.r0);
3290 __put_user(env->regs[1], &sc->regs.r1);
3291 __put_user(env->regs[2], &sc->regs.r2);
3292 __put_user(env->regs[3], &sc->regs.r3);
3293 __put_user(env->regs[4], &sc->regs.r4);
3294 __put_user(env->regs[5], &sc->regs.r5);
3295 __put_user(env->regs[6], &sc->regs.r6);
3296 __put_user(env->regs[7], &sc->regs.r7);
3297 __put_user(env->regs[8], &sc->regs.r8);
3298 __put_user(env->regs[9], &sc->regs.r9);
3299 __put_user(env->regs[10], &sc->regs.r10);
3300 __put_user(env->regs[11], &sc->regs.r11);
3301 __put_user(env->regs[12], &sc->regs.r12);
3302 __put_user(env->regs[13], &sc->regs.r13);
3303 __put_user(env->regs[14], &sc->usp);
3304 __put_user(env->regs[15], &sc->regs.acr);
3305 __put_user(env->pregs[PR_MOF], &sc->regs.mof);
3306 __put_user(env->pregs[PR_SRP], &sc->regs.srp);
3307 __put_user(env->pc, &sc->regs.erp);
b6d3abda 3308}
9664d928 3309
b6d3abda
EI		 3310static void restore_sigcontext(struct target_sigcontext *sc, CPUState *env)
3311{
9664d928
EI		 3312 __get_user(env->regs[0], &sc->regs.r0);
3313 __get_user(env->regs[1], &sc->regs.r1);
3314 __get_user(env->regs[2], &sc->regs.r2);
3315 __get_user(env->regs[3], &sc->regs.r3);
3316 __get_user(env->regs[4], &sc->regs.r4);
3317 __get_user(env->regs[5], &sc->regs.r5);
3318 __get_user(env->regs[6], &sc->regs.r6);
3319 __get_user(env->regs[7], &sc->regs.r7);
3320 __get_user(env->regs[8], &sc->regs.r8);
3321 __get_user(env->regs[9], &sc->regs.r9);
3322 __get_user(env->regs[10], &sc->regs.r10);
3323 __get_user(env->regs[11], &sc->regs.r11);
3324 __get_user(env->regs[12], &sc->regs.r12);
3325 __get_user(env->regs[13], &sc->regs.r13);
3326 __get_user(env->regs[14], &sc->usp);
3327 __get_user(env->regs[15], &sc->regs.acr);
3328 __get_user(env->pregs[PR_MOF], &sc->regs.mof);
3329 __get_user(env->pregs[PR_SRP], &sc->regs.srp);
3330 __get_user(env->pc, &sc->regs.erp);
3331}
3332
3333static abi_ulong get_sigframe(CPUState *env, int framesize)
3334{
3335 abi_ulong sp;
b6d3abda 3336 /* Align the stack downwards to 4. */
9664d928
EI		 3337 sp = (env->regs[R_SP] & ~3);
3338 return sp - framesize;
b6d3abda
EI		 3339}
3340
624f7979 3341static void setup_frame(int sig, struct target_sigaction *ka,
b6d3abda
EI		 3342 target_sigset_t *set, CPUState *env)
3343{
3344 struct target_signal_frame *frame;
9664d928 3345 abi_ulong frame_addr;
b6d3abda
EI		 3346 int err = 0;
3347 int i;
b6d3abda 3348
9664d928
EI		 3349 frame_addr = get_sigframe(env, sizeof *frame);
3350 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
b6d3abda
EI		 3351 goto badframe;
3352
3353 /*
3354 * The CRIS signal return trampoline. A real linux/CRIS kernel doesn't
3355 * use this trampoline anymore but it sets it up for GDB.
3356 * In QEMU, using the trampoline simplifies things a bit so we use it.
3357 *
3358 * This is movu.w __NR_sigreturn, r9; break 13;
3359 */
3360 err |= __put_user(0x9c5f, frame->retcode+0);
3361 err |= __put_user(TARGET_NR_sigreturn,
3362 frame->retcode+2);
3363 err |= __put_user(0xe93d, frame->retcode+4);
3364
3365 /* Save the mask. */
3366 err |= __put_user(set->sig[0], &frame->sc.oldmask);
3367 if (err)
3368 goto badframe;
3369
3370 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3371 if (__put_user(set->sig[i], &frame->extramask[i - 1]))
3372 goto badframe;
3373 }
3374
3375 setup_sigcontext(&frame->sc, env);
3376
3377 /* Move the stack and setup the arguments for the handler. */
526ccb7a 3378 env->regs[R_SP] = (uint32_t) (unsigned long) frame;
b6d3abda 3379 env->regs[10] = sig;
624f7979 3380 env->pc = (unsigned long) ka->_sa_handler;
b6d3abda 3381 /* Link SRP so the guest returns through the trampoline. */
526ccb7a 3382 env->pregs[PR_SRP] = (uint32_t) (unsigned long) &frame->retcode[0];
b6d3abda 3383
9664d928 3384 unlock_user_struct(frame, frame_addr, 1);
b6d3abda
EI		 3385 return;
3386 badframe:
9664d928 3387 unlock_user_struct(frame, frame_addr, 1);
b6d3abda
EI		 3388 force_sig(TARGET_SIGSEGV);
3389}
3390
624f7979 3391static void setup_rt_frame(int sig, struct target_sigaction *ka,
b6d3abda
EI		 3392 target_siginfo_t *info,
3393 target_sigset_t *set, CPUState *env)
3394{
3395 fprintf(stderr, "CRIS setup_rt_frame: not implemented\n");
3396}
3397
3398long do_sigreturn(CPUState *env)
3399{
3400 struct target_signal_frame *frame;
9664d928 3401 abi_ulong frame_addr;
b6d3abda
EI		 3402 target_sigset_t target_set;
3403 sigset_t set;
3404 int i;
3405
9664d928 3406 frame_addr = env->regs[R_SP];
b6d3abda 3407 /* Make sure the guest isn't playing games. */
9664d928 3408 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
b6d3abda
EI		 3409 goto badframe;
3410
3411 /* Restore blocked signals */
3412 if (__get_user(target_set.sig[0], &frame->sc.oldmask))
3413 goto badframe;
3414 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3415 if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
3416 goto badframe;
3417 }
3418 target_to_host_sigset_internal(&set, &target_set);
3419 sigprocmask(SIG_SETMASK, &set, NULL);
3420
3421 restore_sigcontext(&frame->sc, env);
9664d928 3422 unlock_user_struct(frame, frame_addr, 0);
b6d3abda
EI		 3423 return env->regs[10];
3424 badframe:
9664d928 3425 unlock_user_struct(frame, frame_addr, 0);
b6d3abda
EI		 3426 force_sig(TARGET_SIGSEGV);
3427}
3428
3429long do_rt_sigreturn(CPUState *env)
3430{
3431 fprintf(stderr, "CRIS do_rt_sigreturn: not implemented\n");
3432 return -TARGET_ENOSYS;
3433}
c3b5bc8a 3434
bcd4933a
NF		 3435#elif defined(TARGET_PPC) && !defined(TARGET_PPC64)
3436
3437/* FIXME: Many of the structures are defined for both PPC and PPC64, but
3438 the signal handling is different enough that we haven't implemented
3439 support for PPC64 yet. Hence the restriction above.
3440
3441 There are various #if'd blocks for code for TARGET_PPC64. These
3442 blocks should go away so that we can successfully run 32-bit and
3443 64-bit binaries on a QEMU configured for PPC64. */
3444
3445/* Size of dummy stack frame allocated when calling signal handler.
3446 See arch/powerpc/include/asm/ptrace.h. */
3447#if defined(TARGET_PPC64)
3448#define SIGNAL_FRAMESIZE 128
3449#else
3450#define SIGNAL_FRAMESIZE 64
3451#endif
3452
3453/* See arch/powerpc/include/asm/sigcontext.h. */
3454struct target_sigcontext {
3455 target_ulong _unused[4];
3456 int32_t signal;
3457#if defined(TARGET_PPC64)
3458 int32_t pad0;
3459#endif
3460 target_ulong handler;
3461 target_ulong oldmask;
3462 target_ulong regs; /* struct pt_regs __user * */
3463 /* TODO: PPC64 includes extra bits here. */
3464};
3465
3466/* Indices for target_mcontext.mc_gregs, below.
3467 See arch/powerpc/include/asm/ptrace.h for details. */
3468enum {
3469 TARGET_PT_R0 = 0,
3470 TARGET_PT_R1 = 1,
3471 TARGET_PT_R2 = 2,
3472 TARGET_PT_R3 = 3,
3473 TARGET_PT_R4 = 4,
3474 TARGET_PT_R5 = 5,
3475 TARGET_PT_R6 = 6,
3476 TARGET_PT_R7 = 7,
3477 TARGET_PT_R8 = 8,
3478 TARGET_PT_R9 = 9,
3479 TARGET_PT_R10 = 10,
3480 TARGET_PT_R11 = 11,
3481 TARGET_PT_R12 = 12,
3482 TARGET_PT_R13 = 13,
3483 TARGET_PT_R14 = 14,
3484 TARGET_PT_R15 = 15,
3485 TARGET_PT_R16 = 16,
3486 TARGET_PT_R17 = 17,
3487 TARGET_PT_R18 = 18,
3488 TARGET_PT_R19 = 19,
3489 TARGET_PT_R20 = 20,
3490 TARGET_PT_R21 = 21,
3491 TARGET_PT_R22 = 22,
3492 TARGET_PT_R23 = 23,
3493 TARGET_PT_R24 = 24,
3494 TARGET_PT_R25 = 25,
3495 TARGET_PT_R26 = 26,
3496 TARGET_PT_R27 = 27,
3497 TARGET_PT_R28 = 28,
3498 TARGET_PT_R29 = 29,
3499 TARGET_PT_R30 = 30,
3500 TARGET_PT_R31 = 31,
3501 TARGET_PT_NIP = 32,
3502 TARGET_PT_MSR = 33,
3503 TARGET_PT_ORIG_R3 = 34,
3504 TARGET_PT_CTR = 35,
3505 TARGET_PT_LNK = 36,
3506 TARGET_PT_XER = 37,
3507 TARGET_PT_CCR = 38,
3508 /* Yes, there are two registers with #39. One is 64-bit only. */
3509 TARGET_PT_MQ = 39,
3510 TARGET_PT_SOFTE = 39,
3511 TARGET_PT_TRAP = 40,
3512 TARGET_PT_DAR = 41,
3513 TARGET_PT_DSISR = 42,
3514 TARGET_PT_RESULT = 43,
3515 TARGET_PT_REGS_COUNT = 44
3516};
3517
3518/* See arch/powerpc/include/asm/ucontext.h. Only used for 32-bit PPC;
3519 on 64-bit PPC, sigcontext and mcontext are one and the same. */
3520struct target_mcontext {
3521 target_ulong mc_gregs[48];
3522 /* Includes fpscr. */
3523 uint64_t mc_fregs[33];
3524 target_ulong mc_pad[2];
3525 /* We need to handle Altivec and SPE at the same time, which no
3526 kernel needs to do. Fortunately, the kernel defines this bit to
3527 be Altivec-register-large all the time, rather than trying to
3528 twiddle it based on the specific platform. */
3529 union {
3530 /* SPE vector registers. One extra for SPEFSCR. */
3531 uint32_t spe[33];
3532 /* Altivec vector registers. The packing of VSCR and VRSAVE
3533 varies depending on whether we're PPC64 or not: PPC64 splits
3534 them apart; PPC32 stuffs them together. */
3535#if defined(TARGET_PPC64)
3536#define NVRREG 34
3537#else
3538#define NVRREG 33
3539#endif
3540 ppc_avr_t altivec[NVRREG];
3541#undef NVRREG
3542 } mc_vregs __attribute__((__aligned__(16)));
3543};
3544
3545struct target_ucontext {
3546 target_ulong uc_flags;
3547 target_ulong uc_link; /* struct ucontext __user * */
3548 struct target_sigaltstack uc_stack;
3549#if !defined(TARGET_PPC64)
3550 int32_t uc_pad[7];
3551 target_ulong uc_regs; /* struct mcontext __user *
3552 points to uc_mcontext field */
3553#endif
3554 target_sigset_t uc_sigmask;
3555#if defined(TARGET_PPC64)
3556 target_sigset_t unused[15]; /* Allow for uc_sigmask growth */
3557 struct target_sigcontext uc_mcontext;
3558#else
3559 int32_t uc_maskext[30];
3560 int32_t uc_pad2[3];
3561 struct target_mcontext uc_mcontext;
3562#endif
3563};
3564
3565/* See arch/powerpc/kernel/signal_32.c. */
3566struct target_sigframe {
3567 struct target_sigcontext sctx;
3568 struct target_mcontext mctx;
3569 int32_t abigap[56];
3570};
3571
3572struct target_rt_sigframe {
3573 struct target_siginfo info;
3574 struct target_ucontext uc;
3575 int32_t abigap[56];
3576};
3577
3578/* We use the mc_pad field for the signal return trampoline. */
3579#define tramp mc_pad
3580
3581/* See arch/powerpc/kernel/signal.c. */
3582static target_ulong get_sigframe(struct target_sigaction *ka,
3583 CPUState *env,
3584 int frame_size)
3585{
3586 target_ulong oldsp, newsp;
3587
3588 oldsp = env->gpr[1];
3589
3590 if ((ka->sa_flags & TARGET_SA_ONSTACK) &&
3591 (sas_ss_flags(oldsp))) {
3592 oldsp = (target_sigaltstack_used.ss_sp
3593 + target_sigaltstack_used.ss_size);
3594 }
3595
3596 newsp = (oldsp - frame_size) & ~0xFUL;
3597
3598 return newsp;
3599}
3600
3601static int save_user_regs(CPUState *env, struct target_mcontext *frame,
3602 int sigret)
3603{
3604 target_ulong msr = env->msr;
3605 int i;
3606 target_ulong ccr = 0;
3607
3608 /* In general, the kernel attempts to be intelligent about what it
3609 needs to save for Altivec/FP/SPE registers. We don't care that
3610 much, so we just go ahead and save everything. */
3611
3612 /* Save general registers. */
3613 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
3614 if (__put_user(env->gpr[i], &frame->mc_gregs[i])) {
3615 return 1;
3616 }
3617 }
3618 if (__put_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP])
3619 || __put_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR])
3620 || __put_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK])
3621 || __put_user(env->xer, &frame->mc_gregs[TARGET_PT_XER]))
3622 return 1;
3623
3624 for (i = 0; i < ARRAY_SIZE(env->crf); i++) {
3625 ccr |= env->crf[i] << (32 - ((i + 1) * 4));
3626 }
3627 if (__put_user(ccr, &frame->mc_gregs[TARGET_PT_CCR]))
3628 return 1;
3629
3630 /* Save Altivec registers if necessary. */
3631 if (env->insns_flags & PPC_ALTIVEC) {
3632 for (i = 0; i < ARRAY_SIZE(env->avr); i++) {
3633 ppc_avr_t *avr = &env->avr[i];
3634 ppc_avr_t *vreg = &frame->mc_vregs.altivec[i];
3635
3636 if (__put_user(avr->u64[0], &vreg->u64[0]) ||
3637 __put_user(avr->u64[1], &vreg->u64[1])) {
3638 return 1;
3639 }
3640 }
3641 /* Set MSR_VR in the saved MSR value to indicate that
3642 frame->mc_vregs contains valid data. */
3643 msr |= MSR_VR;
3644 if (__put_user((uint32_t)env->spr[SPR_VRSAVE],
3645 &frame->mc_vregs.altivec[32].u32[3]))
3646 return 1;
3647 }
3648
3649 /* Save floating point registers. */
3650 if (env->insns_flags & PPC_FLOAT) {
3651 for (i = 0; i < ARRAY_SIZE(env->fpr); i++) {
3652 if (__put_user(env->fpr[i], &frame->mc_fregs[i])) {
3653 return 1;
3654 }
3655 }
3656 if (__put_user((uint64_t) env->fpscr, &frame->mc_fregs[32]))
3657 return 1;
3658 }
3659
3660 /* Save SPE registers. The kernel only saves the high half. */
3661 if (env->insns_flags & PPC_SPE) {
3662#if defined(TARGET_PPC64)
3663 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
3664 if (__put_user(env->gpr[i] >> 32, &frame->mc_vregs.spe[i])) {
3665 return 1;
3666 }
3667 }
3668#else
3669 for (i = 0; i < ARRAY_SIZE(env->gprh); i++) {
3670 if (__put_user(env->gprh[i], &frame->mc_vregs.spe[i])) {
3671 return 1;
3672 }
3673 }
3674#endif
3675 /* Set MSR_SPE in the saved MSR value to indicate that
3676 frame->mc_vregs contains valid data. */
3677 msr |= MSR_SPE;
3678 if (__put_user(env->spe_fscr, &frame->mc_vregs.spe[32]))
3679 return 1;
3680 }
3681
3682 /* Store MSR. */
3683 if (__put_user(msr, &frame->mc_gregs[TARGET_PT_MSR]))
3684 return 1;
3685
3686 /* Set up the sigreturn trampoline: li r0,sigret; sc. */
3687 if (sigret) {
3688 if (__put_user(0x38000000UL | sigret, &frame->tramp[0]) ||
3689 __put_user(0x44000002UL, &frame->tramp[1])) {
3690 return 1;
3691 }
3692 }
3693
3694 return 0;
3695}
3696
3697static int restore_user_regs(CPUState *env,
3698 struct target_mcontext *frame, int sig)
3699{
3700 target_ulong save_r2 = 0;
3701 target_ulong msr;
3702 target_ulong ccr;
3703
3704 int i;
3705
3706 if (!sig) {
3707 save_r2 = env->gpr[2];
3708 }
3709
3710 /* Restore general registers. */
3711 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
3712 if (__get_user(env->gpr[i], &frame->mc_gregs[i])) {
3713 return 1;
3714 }
3715 }
3716 if (__get_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP])
3717 || __get_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR])
3718 || __get_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK])
3719 || __get_user(env->xer, &frame->mc_gregs[TARGET_PT_XER]))
3720 return 1;
3721 if (__get_user(ccr, &frame->mc_gregs[TARGET_PT_CCR]))
3722 return 1;
3723
3724 for (i = 0; i < ARRAY_SIZE(env->crf); i++) {
3725 env->crf[i] = (ccr >> (32 - ((i + 1) * 4))) & 0xf;
3726 }
3727
3728 if (!sig) {
3729 env->gpr[2] = save_r2;
3730 }
3731 /* Restore MSR. */
3732 if (__get_user(msr, &frame->mc_gregs[TARGET_PT_MSR]))
3733 return 1;
3734
3735 /* If doing signal return, restore the previous little-endian mode. */
3736 if (sig)
3737 env->msr = (env->msr & ~MSR_LE) | (msr & MSR_LE);
3738
3739 /* Restore Altivec registers if necessary. */
3740 if (env->insns_flags & PPC_ALTIVEC) {
3741 for (i = 0; i < ARRAY_SIZE(env->avr); i++) {
3742 ppc_avr_t *avr = &env->avr[i];
3743 ppc_avr_t *vreg = &frame->mc_vregs.altivec[i];
3744
3745 if (__get_user(avr->u64[0], &vreg->u64[0]) ||
3746 __get_user(avr->u64[1], &vreg->u64[1])) {
3747 return 1;
3748 }
3749 }
3750 /* Set MSR_VEC in the saved MSR value to indicate that
3751 frame->mc_vregs contains valid data. */
3752 if (__get_user(env->spr[SPR_VRSAVE],
3753 (target_ulong *)(&frame->mc_vregs.altivec[32].u32[3])))
3754 return 1;
3755 }
3756
3757 /* Restore floating point registers. */
3758 if (env->insns_flags & PPC_FLOAT) {
3759 uint64_t fpscr;
3760 for (i = 0; i < ARRAY_SIZE(env->fpr); i++) {
3761 if (__get_user(env->fpr[i], &frame->mc_fregs[i])) {
3762 return 1;
3763 }
3764 }
3765 if (__get_user(fpscr, &frame->mc_fregs[32]))
3766 return 1;
3767 env->fpscr = (uint32_t) fpscr;
3768 }
3769
3770 /* Save SPE registers. The kernel only saves the high half. */
3771 if (env->insns_flags & PPC_SPE) {
3772#if defined(TARGET_PPC64)
3773 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
3774 uint32_t hi;
3775
3776 if (__get_user(hi, &frame->mc_vregs.spe[i])) {
3777 return 1;
3778 }
3779 env->gpr[i] = ((uint64_t)hi << 32) | ((uint32_t) env->gpr[i]);
3780 }
3781#else
3782 for (i = 0; i < ARRAY_SIZE(env->gprh); i++) {
3783 if (__get_user(env->gprh[i], &frame->mc_vregs.spe[i])) {
3784 return 1;
3785 }
3786 }
3787#endif
3788 if (__get_user(env->spe_fscr, &frame->mc_vregs.spe[32]))
3789 return 1;
3790 }
3791
3792 return 0;
3793}
3794
3795static void setup_frame(int sig, struct target_sigaction *ka,
3796 target_sigset_t *set, CPUState *env)
3797{
3798 struct target_sigframe *frame;
3799 struct target_sigcontext *sc;
3800 target_ulong frame_addr, newsp;
3801 int err = 0;
3802 int signal;
3803
3804 frame_addr = get_sigframe(ka, env, sizeof(*frame));
3805 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
3806 goto sigsegv;
3807 sc = &frame->sctx;
3808
3809 signal = current_exec_domain_sig(sig);
3810
3811 err |= __put_user(h2g(ka->_sa_handler), &sc->handler);
3812 err |= __put_user(set->sig[0], &sc->oldmask);
3813#if defined(TARGET_PPC64)
3814 err |= __put_user(set->sig[0] >> 32, &sc->_unused[3]);
3815#else
3816 err |= __put_user(set->sig[1], &sc->_unused[3]);
3817#endif
3818 err |= __put_user(h2g(&frame->mctx), &sc->regs);
3819 err |= __put_user(sig, &sc->signal);
3820
3821 /* Save user regs. */
3822 err |= save_user_regs(env, &frame->mctx, TARGET_NR_sigreturn);
3823
3824 /* The kernel checks for the presence of a VDSO here. We don't
3825 emulate a vdso, so use a sigreturn system call. */
3826 env->lr = (target_ulong) h2g(frame->mctx.tramp);
3827
3828 /* Turn off all fp exceptions. */
3829 env->fpscr = 0;
3830
3831 /* Create a stack frame for the caller of the handler. */
3832 newsp = frame_addr - SIGNAL_FRAMESIZE;
3833 err |= __put_user(env->gpr[1], (target_ulong *)(uintptr_t) newsp);
3834
3835 if (err)
3836 goto sigsegv;
3837
3838 /* Set up registers for signal handler. */
3839 env->gpr[1] = newsp;
3840 env->gpr[3] = signal;
3841 env->gpr[4] = (target_ulong) h2g(sc);
3842 env->nip = (target_ulong) ka->_sa_handler;
3843 /* Signal handlers are entered in big-endian mode. */
3844 env->msr &= ~MSR_LE;
3845
3846 unlock_user_struct(frame, frame_addr, 1);
3847 return;
3848
3849sigsegv:
3850 unlock_user_struct(frame, frame_addr, 1);
3851 if (logfile)
3852 fprintf (logfile, "segfaulting from setup_frame\n");
3853 force_sig(SIGSEGV);
3854}
3855
3856static void setup_rt_frame(int sig, struct target_sigaction *ka,
3857 target_siginfo_t *info,
3858 target_sigset_t *set, CPUState *env)
3859{
3860 struct target_rt_sigframe *rt_sf;
3861 struct target_mcontext *frame;
3862 target_ulong rt_sf_addr, newsp = 0;
3863 int i, err = 0;
3864 int signal;
3865
3866 rt_sf_addr = get_sigframe(ka, env, sizeof(*rt_sf));
3867 if (!lock_user_struct(VERIFY_WRITE, rt_sf, rt_sf_addr, 1))
3868 goto sigsegv;
3869
3870 signal = current_exec_domain_sig(sig);
3871
3872 err |= copy_siginfo_to_user(&rt_sf->info, info);
3873
3874 err |= __put_user(0, &rt_sf->uc.uc_flags);
3875 err |= __put_user(0, &rt_sf->uc.uc_link);
3876 err |= __put_user((target_ulong)target_sigaltstack_used.ss_sp,
3877 &rt_sf->uc.uc_stack.ss_sp);
3878 err |= __put_user(sas_ss_flags(env->gpr[1]),
3879 &rt_sf->uc.uc_stack.ss_flags);
3880 err |= __put_user(target_sigaltstack_used.ss_size,
3881 &rt_sf->uc.uc_stack.ss_size);
3882 err |= __put_user(h2g (&rt_sf->uc.uc_mcontext),
3883 &rt_sf->uc.uc_regs);
3884 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
3885 err |= __put_user(set->sig[i], &rt_sf->uc.uc_sigmask.sig[i]);
3886 }
3887
3888 frame = &rt_sf->uc.uc_mcontext;
3889 err |= save_user_regs(env, frame, TARGET_NR_rt_sigreturn);
3890
3891 /* The kernel checks for the presence of a VDSO here. We don't
3892 emulate a vdso, so use a sigreturn system call. */
3893 env->lr = (target_ulong) h2g(frame->tramp);
3894
3895 /* Turn off all fp exceptions. */
3896 env->fpscr = 0;
3897
3898 /* Create a stack frame for the caller of the handler. */
3899 newsp = rt_sf_addr - (SIGNAL_FRAMESIZE + 16);
3900 err |= __put_user(env->gpr[1], (target_ulong *)(uintptr_t) newsp);
3901
3902 if (err)
3903 goto sigsegv;
3904
3905 /* Set up registers for signal handler. */
3906 env->gpr[1] = newsp;
3907 env->gpr[3] = (target_ulong) signal;
3908 env->gpr[4] = (target_ulong) h2g(&rt_sf->info);
3909 env->gpr[5] = (target_ulong) h2g(&rt_sf->uc);
3910 env->gpr[6] = (target_ulong) h2g(rt_sf);
3911 env->nip = (target_ulong) ka->_sa_handler;
3912 /* Signal handlers are entered in big-endian mode. */
3913 env->msr &= ~MSR_LE;
3914
3915 unlock_user_struct(rt_sf, rt_sf_addr, 1);
3916 return;
3917
3918sigsegv:
3919 unlock_user_struct(rt_sf, rt_sf_addr, 1);
3920 if (logfile)
3921 fprintf (logfile, "segfaulting from setup_rt_frame\n");
3922 force_sig(SIGSEGV);
3923
3924}
3925
3926long do_sigreturn(CPUState *env)
3927{
3928 struct target_sigcontext *sc = NULL;
3929 struct target_mcontext *sr = NULL;
3930 target_ulong sr_addr, sc_addr;
3931 sigset_t blocked;
3932 target_sigset_t set;
3933
3934 sc_addr = env->gpr[1] + SIGNAL_FRAMESIZE;
3935 if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1))
3936 goto sigsegv;
3937
3938#if defined(TARGET_PPC64)
3939 set.sig[0] = sc->oldmask + ((long)(sc->_unused[3]) << 32);
3940#else
3941 if(__get_user(set.sig[0], &sc->oldmask) ||
3942 __get_user(set.sig[1], &sc->_unused[3]))
3943 goto sigsegv;
3944#endif
3945 target_to_host_sigset_internal(&blocked, &set);
3946 sigprocmask(SIG_SETMASK, &blocked, NULL);
3947
3948 if (__get_user(sr_addr, &sc->regs))
3949 goto sigsegv;
3950 if (!lock_user_struct(VERIFY_READ, sr, sr_addr, 1))
3951 goto sigsegv;
3952 if (restore_user_regs(env, sr, 1))
3953 goto sigsegv;
3954
3955 unlock_user_struct(sr, sr_addr, 1);
3956 unlock_user_struct(sc, sc_addr, 1);
3957 return -TARGET_QEMU_ESIGRETURN;
3958
3959sigsegv:
3960 unlock_user_struct(sr, sr_addr, 1);
3961 unlock_user_struct(sc, sc_addr, 1);
3962 if (logfile)
3963 fprintf (logfile, "segfaulting from do_sigreturn\n");
3964 force_sig(SIGSEGV);
3965 return 0;
3966}
3967
3968/* See arch/powerpc/kernel/signal_32.c. */
3969static int do_setcontext(struct target_ucontext *ucp, CPUState *env, int sig)
3970{
3971 struct target_mcontext *mcp;
3972 target_ulong mcp_addr;
3973 sigset_t blocked;
3974 target_sigset_t set;
3975
3976 if (copy_from_user(&set, h2g(ucp) + offsetof(struct target_ucontext, uc_sigmask),
3977 sizeof (set)))
3978 return 1;
3979
3980#if defined(TARGET_PPC64)
3981 fprintf (stderr, "do_setcontext: not implemented\n");
3982 return 0;
3983#else
3984 if (__get_user(mcp_addr, &ucp->uc_regs))
3985 return 1;
3986
3987 if (!lock_user_struct(VERIFY_READ, mcp, mcp_addr, 1))
3988 return 1;
3989
3990 target_to_host_sigset_internal(&blocked, &set);
3991 sigprocmask(SIG_SETMASK, &blocked, NULL);
3992 if (restore_user_regs(env, mcp, sig))
3993 goto sigsegv;
3994
3995 unlock_user_struct(mcp, mcp_addr, 1);
3996 return 0;
3997
3998sigsegv:
3999 unlock_user_struct(mcp, mcp_addr, 1);
4000 return 1;
4001#endif
4002}
4003
4004long do_rt_sigreturn(CPUState *env)
4005{
4006 struct target_rt_sigframe *rt_sf = NULL;
4007 target_ulong rt_sf_addr;
4008
4009 rt_sf_addr = env->gpr[1] + SIGNAL_FRAMESIZE + 16;
4010 if (!lock_user_struct(VERIFY_READ, rt_sf, rt_sf_addr, 1))
4011 goto sigsegv;
4012
4013 if (do_setcontext(&rt_sf->uc, env, 1))
4014 goto sigsegv;
4015
4016 do_sigaltstack(rt_sf_addr
4017 + offsetof(struct target_rt_sigframe, uc.uc_stack),
4018 0, env->gpr[1]);
4019
4020 unlock_user_struct(rt_sf, rt_sf_addr, 1);
4021 return -TARGET_QEMU_ESIGRETURN;
4022
4023sigsegv:
4024 unlock_user_struct(rt_sf, rt_sf_addr, 1);
4025 if (logfile)
4026 fprintf (logfile, "segfaulting from do_rt_sigreturn\n");
4027 force_sig(SIGSEGV);
4028 return 0;
4029}
4030
b346ff46
FB		 4031#else
4032
624f7979 4033static void setup_frame(int sig, struct target_sigaction *ka,
b346ff46
FB		 4034 target_sigset_t *set, CPUState *env)
4035{
4036 fprintf(stderr, "setup_frame: not implemented\n");
4037}
4038
624f7979 4039static void setup_rt_frame(int sig, struct target_sigaction *ka,
b346ff46
FB		 4040 target_siginfo_t *info,
4041 target_sigset_t *set, CPUState *env)
4042{
4043 fprintf(stderr, "setup_rt_frame: not implemented\n");
4044}
4045
4046long do_sigreturn(CPUState *env)
4047{
4048 fprintf(stderr, "do_sigreturn: not implemented\n");
f8b0aa25 4049 return -TARGET_ENOSYS;
b346ff46
FB		 4050}
4051
4052long do_rt_sigreturn(CPUState *env)
4053{
4054 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
f8b0aa25 4055 return -TARGET_ENOSYS;
b346ff46
FB		 4056}
4057
66fb9763
FB		 4058#endif
4059
624f7979 4060void process_pending_signals(CPUState *cpu_env)
66fb9763
FB		 4061{
4062 int sig;
992f48a0 4063 abi_ulong handler;
9de5e440
FB		 4064 sigset_t set, old_set;
4065 target_sigset_t target_old_set;
624f7979
PB		 4066 struct emulated_sigtable *k;
4067 struct target_sigaction *sa;
66fb9763 4068 struct sigqueue *q;
624f7979 4069 TaskState *ts = cpu_env->opaque;
3b46e624 4070
624f7979 4071 if (!ts->signal_pending)
31e31b8a
FB		 4072 return;
4073
624f7979
PB		 4074 /* FIXME: This is not threadsafe. */
4075 k = ts->sigtab;
66fb9763
FB		 4076 for(sig = 1; sig <= TARGET_NSIG; sig++) {
4077 if (k->pending)
31e31b8a 4078 goto handle_signal;
66fb9763 4079 k++;
31e31b8a
FB		 4080 }
4081 /* if no signal is pending, just return */
624f7979 4082 ts->signal_pending = 0;
31e31b8a 4083 return;
66fb9763 4084
31e31b8a 4085 handle_signal:
66fb9763 4086#ifdef DEBUG_SIGNAL
bc8a22cc 4087 fprintf(stderr, "qemu: process signal %d\n", sig);
66fb9763
FB		 4088#endif
4089 /* dequeue signal */
4090 q = k->first;
4091 k->first = q->next;
4092 if (!k->first)
4093 k->pending = 0;
3b46e624 4094
1fddef4b
FB		 4095 sig = gdb_handlesig (cpu_env, sig);
4096 if (!sig) {
ca587a8e
AJ		 4097 sa = NULL;
4098 handler = TARGET_SIG_IGN;
4099 } else {
4100 sa = &sigact_table[sig - 1];
4101 handler = sa->_sa_handler;
1fddef4b 4102 }
66fb9763 4103
66fb9763 4104 if (handler == TARGET_SIG_DFL) {
ca587a8e
AJ		 4105 /* default handler : ignore some signal. The other are job control or fatal */
4106 if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) {
4107 kill(getpid(),SIGSTOP);
4108 } else if (sig != TARGET_SIGCHLD &&
4109 sig != TARGET_SIGURG &&
4110 sig != TARGET_SIGWINCH &&
4111 sig != TARGET_SIGCONT) {
66fb9763
FB		 4112 force_sig(sig);
4113 }
4114 } else if (handler == TARGET_SIG_IGN) {
4115 /* ignore sig */
4116 } else if (handler == TARGET_SIG_ERR) {
4117 force_sig(sig);
4118 } else {
9de5e440 4119 /* compute the blocked signals during the handler execution */
624f7979 4120 target_to_host_sigset(&set, &sa->sa_mask);
9de5e440
FB		 4121 /* SA_NODEFER indicates that the current signal should not be
4122 blocked during the handler */
624f7979 4123 if (!(sa->sa_flags & TARGET_SA_NODEFER))
9de5e440 4124 sigaddset(&set, target_to_host_signal(sig));
3b46e624 4125
9de5e440
FB		 4126 /* block signals in the handler using Linux */
4127 sigprocmask(SIG_BLOCK, &set, &old_set);
4128 /* save the previous blocked signal state to restore it at the
4129 end of the signal execution (see do_sigreturn) */
9231944d 4130 host_to_target_sigset_internal(&target_old_set, &old_set);
9de5e440 4131
bc8a22cc 4132 /* if the CPU is in VM86 mode, we restore the 32 bit values */
84409ddb 4133#if defined(TARGET_I386) && !defined(TARGET_X86_64)
bc8a22cc
FB		 4134 {
4135 CPUX86State *env = cpu_env;
4136 if (env->eflags & VM_MASK)
4137 save_v86_state(env);
4138 }
4139#endif
9de5e440 4140 /* prepare the stack frame of the virtual CPU */
624f7979
PB		 4141 if (sa->sa_flags & TARGET_SA_SIGINFO)
4142 setup_rt_frame(sig, sa, &q->info, &target_old_set, cpu_env);
66fb9763 4143 else
624f7979
PB		 4144 setup_frame(sig, sa, &target_old_set, cpu_env);
4145 if (sa->sa_flags & TARGET_SA_RESETHAND)
4146 sa->_sa_handler = TARGET_SIG_DFL;
31e31b8a 4147 }
66fb9763 4148 if (q != &k->info)
624f7979 4149 free_sigqueue(cpu_env, q);
66fb9763 4150}
Qemu copy for testing