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