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