]> git.proxmox.com Git - qemu.git/blame - linux-user/signal.c
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
atomic.h: Fix build with clang
[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
1744aea1
AS		 1095#elif defined(TARGET_AARCH64)
1096
1097struct target_sigcontext {
1098 uint64_t fault_address;
1099 /* AArch64 registers */
1100 uint64_t regs[31];
1101 uint64_t sp;
1102 uint64_t pc;
1103 uint64_t pstate;
1104 /* 4K reserved for FP/SIMD state and future expansion */
1105 char __reserved[4096] __attribute__((__aligned__(16)));
1106};
1107
1108struct target_ucontext {
1109 abi_ulong tuc_flags;
1110 abi_ulong tuc_link;
1111 target_stack_t tuc_stack;
1112 target_sigset_t tuc_sigmask;
1113 /* glibc uses a 1024-bit sigset_t */
1114 char __unused[1024 / 8 - sizeof(target_sigset_t)];
1115 /* last for future expansion */
1116 struct target_sigcontext tuc_mcontext;
1117};
1118
1119/*
1120 * Header to be used at the beginning of structures extending the user
1121 * context. Such structures must be placed after the rt_sigframe on the stack
1122 * and be 16-byte aligned. The last structure must be a dummy one with the
1123 * magic and size set to 0.
1124 */
1125struct target_aarch64_ctx {
1126 uint32_t magic;
1127 uint32_t size;
1128};
1129
1130#define TARGET_FPSIMD_MAGIC 0x46508001
1131
1132struct target_fpsimd_context {
1133 struct target_aarch64_ctx head;
1134 uint32_t fpsr;
1135 uint32_t fpcr;
1136 uint64_t vregs[32 * 2]; /* really uint128_t vregs[32] */
1137};
1138
1139/*
1140 * Auxiliary context saved in the sigcontext.__reserved array. Not exported to
1141 * user space as it will change with the addition of new context. User space
1142 * should check the magic/size information.
1143 */
1144struct target_aux_context {
1145 struct target_fpsimd_context fpsimd;
1146 /* additional context to be added before "end" */
1147 struct target_aarch64_ctx end;
1148};
1149
1150struct target_rt_sigframe {
1151 struct target_siginfo info;
1152 struct target_ucontext uc;
1153 uint64_t fp;
1154 uint64_t lr;
1155 uint32_t tramp[2];
1156};
1157
1158static int target_setup_sigframe(struct target_rt_sigframe *sf,
1159 CPUARMState *env, target_sigset_t *set)
1160{
1161 int i;
1162 struct target_aux_context *aux =
1163 (struct target_aux_context *)sf->uc.tuc_mcontext.__reserved;
1164
1165 /* set up the stack frame for unwinding */
1166 __put_user(env->xregs[29], &sf->fp);
1167 __put_user(env->xregs[30], &sf->lr);
1168
1169 for (i = 0; i < 31; i++) {
1170 __put_user(env->xregs[i], &sf->uc.tuc_mcontext.regs[i]);
1171 }
1172 __put_user(env->xregs[31], &sf->uc.tuc_mcontext.sp);
1173 __put_user(env->pc, &sf->uc.tuc_mcontext.pc);
1174 __put_user(env->pstate, &sf->uc.tuc_mcontext.pstate);
1175
1176 __put_user(/*current->thread.fault_address*/ 0,
1177 &sf->uc.tuc_mcontext.fault_address);
1178
1179 for (i = 0; i < TARGET_NSIG_WORDS; i++) {
1180 __put_user(set->sig[i], &sf->uc.tuc_sigmask.sig[i]);
1181 }
1182
1183 for (i = 0; i < 32; i++) {
1184#ifdef TARGET_WORDS_BIGENDIAN
1185 __put_user(env->vfp.regs[i * 2], &aux->fpsimd.vregs[i * 2 + 1]);
1186 __put_user(env->vfp.regs[i * 2 + 1], &aux->fpsimd.vregs[i * 2]);
1187#else
1188 __put_user(env->vfp.regs[i * 2], &aux->fpsimd.vregs[i * 2]);
1189 __put_user(env->vfp.regs[i * 2 + 1], &aux->fpsimd.vregs[i * 2 + 1]);
1190#endif
1191 }
1192 __put_user(/*env->fpsr*/0, &aux->fpsimd.fpsr);
1193 __put_user(/*env->fpcr*/0, &aux->fpsimd.fpcr);
1194 __put_user(TARGET_FPSIMD_MAGIC, &aux->fpsimd.head.magic);
1195 __put_user(sizeof(struct target_fpsimd_context),
1196 &aux->fpsimd.head.size);
1197
1198 /* set the "end" magic */
1199 __put_user(0, &aux->end.magic);
1200 __put_user(0, &aux->end.size);
1201
1202 return 0;
1203}
1204
1205static int target_restore_sigframe(CPUARMState *env,
1206 struct target_rt_sigframe *sf)
1207{
1208 sigset_t set;
1209 int i;
1210 struct target_aux_context *aux =
1211 (struct target_aux_context *)sf->uc.tuc_mcontext.__reserved;
1212 uint32_t magic, size;
1213
1214 target_to_host_sigset(&set, &sf->uc.tuc_sigmask);
1215 sigprocmask(SIG_SETMASK, &set, NULL);
1216
1217 for (i = 0; i < 31; i++) {
1218 __get_user(env->xregs[i], &sf->uc.tuc_mcontext.regs[i]);
1219 }
1220
1221 __get_user(env->xregs[31], &sf->uc.tuc_mcontext.sp);
1222 __get_user(env->pc, &sf->uc.tuc_mcontext.pc);
1223 __get_user(env->pstate, &sf->uc.tuc_mcontext.pstate);
1224
1225 __get_user(magic, &aux->fpsimd.head.magic);
1226 __get_user(size, &aux->fpsimd.head.size);
1227
1228 if (magic != TARGET_FPSIMD_MAGIC
1229 || size != sizeof(struct target_fpsimd_context)) {
1230 return 1;
1231 }
1232
1233 for (i = 0; i < 32 * 2; i++) {
1234 __get_user(env->vfp.regs[i], &aux->fpsimd.vregs[i]);
1235 }
1236
1237 return 0;
1238}
1239
1240static abi_ulong get_sigframe(struct target_sigaction *ka, CPUARMState *env)
1241{
1242 abi_ulong sp;
1243
1244 sp = env->xregs[31];
1245
1246 /*
1247 * This is the X/Open sanctioned signal stack switching.
1248 */
1249 if ((ka->sa_flags & SA_ONSTACK) && !sas_ss_flags(sp)) {
1250 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
1251 }
1252
1253 sp = (sp - sizeof(struct target_rt_sigframe)) & ~15;
1254
1255 return sp;
1256}
1257
1258static void target_setup_frame(int usig, struct target_sigaction *ka,
1259 target_siginfo_t *info, target_sigset_t *set,
1260 CPUARMState *env)
1261{
1262 struct target_rt_sigframe *frame;
1263 abi_ulong frame_addr;
1264
1265 frame_addr = get_sigframe(ka, env);
1266 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
1267 goto give_sigsegv;
1268 }
1269
1270 __put_user(0, &frame->uc.tuc_flags);
1271 __put_user(0, &frame->uc.tuc_link);
1272
1273 __put_user(target_sigaltstack_used.ss_sp,
1274 &frame->uc.tuc_stack.ss_sp);
1275 __put_user(sas_ss_flags(env->xregs[31]),
1276 &frame->uc.tuc_stack.ss_flags);
1277 __put_user(target_sigaltstack_used.ss_size,
1278 &frame->uc.tuc_stack.ss_size);
1279 target_setup_sigframe(frame, env, set);
1280 /* mov x8,#__NR_rt_sigreturn; svc #0 */
1281 __put_user(0xd2801168, &frame->tramp[0]);
1282 __put_user(0xd4000001, &frame->tramp[1]);
1283 env->xregs[0] = usig;
1284 env->xregs[31] = frame_addr;
1285 env->xregs[29] = env->xregs[31] + offsetof(struct target_rt_sigframe, fp);
1286 env->pc = ka->_sa_handler;
1287 env->xregs[30] = env->xregs[31] +
1288 offsetof(struct target_rt_sigframe, tramp);
1289 if (info) {
1290 if (copy_siginfo_to_user(&frame->info, info)) {
1291 goto give_sigsegv;
1292 }
1293 env->xregs[1] = frame_addr + offsetof(struct target_rt_sigframe, info);
1294 env->xregs[2] = frame_addr + offsetof(struct target_rt_sigframe, uc);
1295 }
1296
1297 unlock_user_struct(frame, frame_addr, 1);
1298 return;
1299
1300 give_sigsegv:
1301 unlock_user_struct(frame, frame_addr, 1);
1302 force_sig(TARGET_SIGSEGV);
1303}
1304
1305static void setup_rt_frame(int sig, struct target_sigaction *ka,
1306 target_siginfo_t *info, target_sigset_t *set,
1307 CPUARMState *env)
1308{
1309 target_setup_frame(sig, ka, info, set, env);
1310}
1311
1312static void setup_frame(int sig, struct target_sigaction *ka,
1313 target_sigset_t *set, CPUARMState *env)
1314{
1315 target_setup_frame(sig, ka, 0, set, env);
1316}
1317
1318long do_rt_sigreturn(CPUARMState *env)
1319{
1320 struct target_rt_sigframe *frame;
1321 abi_ulong frame_addr = env->xregs[31];
1322
1323 if (frame_addr & 15) {
1324 goto badframe;
1325 }
1326
1327 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
1328 goto badframe;
1329 }
1330
1331 if (target_restore_sigframe(env, frame)) {
1332 goto badframe;
1333 }
1334
1335 if (do_sigaltstack(frame_addr +
1336 offsetof(struct target_rt_sigframe, uc.tuc_stack),
1337 0, get_sp_from_cpustate(env)) == -EFAULT) {
1338 goto badframe;
1339 }
1340
1341 unlock_user_struct(frame, frame_addr, 0);
1342 return env->xregs[0];
1343
1344 badframe:
1345 unlock_user_struct(frame, frame_addr, 0);
1346 force_sig(TARGET_SIGSEGV);
1347 return 0;
1348}
1349
1350long do_sigreturn(CPUARMState *env)
1351{
1352 return do_rt_sigreturn(env);
1353}
1354
43fff238
FB		 1355#elif defined(TARGET_ARM)
1356
1357struct target_sigcontext {
992f48a0
BS		 1358 abi_ulong trap_no;
1359 abi_ulong error_code;
1360 abi_ulong oldmask;
1361 abi_ulong arm_r0;
1362 abi_ulong arm_r1;
1363 abi_ulong arm_r2;
1364 abi_ulong arm_r3;
1365 abi_ulong arm_r4;
1366 abi_ulong arm_r5;
1367 abi_ulong arm_r6;
1368 abi_ulong arm_r7;
1369 abi_ulong arm_r8;
1370 abi_ulong arm_r9;
1371 abi_ulong arm_r10;
1372 abi_ulong arm_fp;
1373 abi_ulong arm_ip;
1374 abi_ulong arm_sp;
1375 abi_ulong arm_lr;
1376 abi_ulong arm_pc;
1377 abi_ulong arm_cpsr;
1378 abi_ulong fault_address;
43fff238
FB		 1379};
1380
a745ec6d
PB		 1381struct target_ucontext_v1 {
1382 abi_ulong tuc_flags;
1383 abi_ulong tuc_link;
c227f099 1384 target_stack_t tuc_stack;
a745ec6d 1385 struct target_sigcontext tuc_mcontext;
c227f099 1386 target_sigset_t tuc_sigmask; /* mask last for extensibility */
a745ec6d
PB		 1387};
1388
1389struct target_ucontext_v2 {
992f48a0
BS		 1390 abi_ulong tuc_flags;
1391 abi_ulong tuc_link;
c227f099 1392 target_stack_t tuc_stack;
b8076a74 1393 struct target_sigcontext tuc_mcontext;
c227f099 1394 target_sigset_t tuc_sigmask; /* mask last for extensibility */
5f0b7c88 1395 char __unused[128 - sizeof(target_sigset_t)];
a745ec6d 1396 abi_ulong tuc_regspace[128] __attribute__((__aligned__(8)));
43fff238
FB		 1397};
1398
0d871bdb
PM		 1399struct target_user_vfp {
1400 uint64_t fpregs[32];
1401 abi_ulong fpscr;
1402};
1403
1404struct target_user_vfp_exc {
1405 abi_ulong fpexc;
1406 abi_ulong fpinst;
1407 abi_ulong fpinst2;
1408};
1409
1410struct target_vfp_sigframe {
1411 abi_ulong magic;
1412 abi_ulong size;
1413 struct target_user_vfp ufp;
1414 struct target_user_vfp_exc ufp_exc;
1415} __attribute__((__aligned__(8)));
1416
08e11256
PM		 1417struct target_iwmmxt_sigframe {
1418 abi_ulong magic;
1419 abi_ulong size;
1420 uint64_t regs[16];
1421 /* Note that not all the coprocessor control registers are stored here */
1422 uint32_t wcssf;
1423 uint32_t wcasf;
1424 uint32_t wcgr0;
1425 uint32_t wcgr1;
1426 uint32_t wcgr2;
1427 uint32_t wcgr3;
1428} __attribute__((__aligned__(8)));
1429
0d871bdb 1430#define TARGET_VFP_MAGIC 0x56465001
08e11256 1431#define TARGET_IWMMXT_MAGIC 0x12ef842a
0d871bdb 1432
a8c33204 1433struct sigframe_v1
43fff238
FB		 1434{
1435 struct target_sigcontext sc;
992f48a0
BS		 1436 abi_ulong extramask[TARGET_NSIG_WORDS-1];
1437 abi_ulong retcode;
43fff238
FB		 1438};
1439
a8c33204
PB		 1440struct sigframe_v2
1441{
1442 struct target_ucontext_v2 uc;
1443 abi_ulong retcode;
1444};
1445
a745ec6d 1446struct rt_sigframe_v1
43fff238 1447{
f8b0aa25
FB		 1448 abi_ulong pinfo;
1449 abi_ulong puc;
43fff238 1450 struct target_siginfo info;
a745ec6d
PB		 1451 struct target_ucontext_v1 uc;
1452 abi_ulong retcode;
1453};
1454
1455struct rt_sigframe_v2
1456{
1457 struct target_siginfo info;
1458 struct target_ucontext_v2 uc;
992f48a0 1459 abi_ulong retcode;
43fff238
FB		 1460};
1461
1462#define TARGET_CONFIG_CPU_32 1
1463
1464/*
1465 * For ARM syscalls, we encode the syscall number into the instruction.
1466 */
1467#define SWI_SYS_SIGRETURN (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE))
1468#define SWI_SYS_RT_SIGRETURN (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE))
1469
1470/*
1471 * For Thumb syscalls, we pass the syscall number via r7. We therefore
1472 * need two 16-bit instructions.
1473 */
1474#define SWI_THUMB_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn))
1475#define SWI_THUMB_RT_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn))
1476
992f48a0 1477static const abi_ulong retcodes[4] = {
43fff238
FB		 1478 SWI_SYS_SIGRETURN, SWI_THUMB_SIGRETURN,
1479 SWI_SYS_RT_SIGRETURN, SWI_THUMB_RT_SIGRETURN
1480};
1481
1482
43fff238
FB		 1483#define __get_user_error(x,p,e) __get_user(x, p)
1484
05390248 1485static inline int valid_user_regs(CPUARMState *regs)
43fff238
FB		 1486{
1487 return 1;
1488}
1489
a8c33204 1490static void
43fff238 1491setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
05390248 1492 CPUARMState *env, abi_ulong mask)
43fff238 1493{
a8c33204
PB		 1494 __put_user(env->regs[0], &sc->arm_r0);
1495 __put_user(env->regs[1], &sc->arm_r1);
1496 __put_user(env->regs[2], &sc->arm_r2);
1497 __put_user(env->regs[3], &sc->arm_r3);
1498 __put_user(env->regs[4], &sc->arm_r4);
1499 __put_user(env->regs[5], &sc->arm_r5);
1500 __put_user(env->regs[6], &sc->arm_r6);
1501 __put_user(env->regs[7], &sc->arm_r7);
1502 __put_user(env->regs[8], &sc->arm_r8);
1503 __put_user(env->regs[9], &sc->arm_r9);
1504 __put_user(env->regs[10], &sc->arm_r10);
1505 __put_user(env->regs[11], &sc->arm_fp);
1506 __put_user(env->regs[12], &sc->arm_ip);
1507 __put_user(env->regs[13], &sc->arm_sp);
1508 __put_user(env->regs[14], &sc->arm_lr);
1509 __put_user(env->regs[15], &sc->arm_pc);
43fff238 1510#ifdef TARGET_CONFIG_CPU_32
a8c33204 1511 __put_user(cpsr_read(env), &sc->arm_cpsr);
43fff238
FB		 1512#endif
1513
a8c33204
PB		 1514 __put_user(/* current->thread.trap_no */ 0, &sc->trap_no);
1515 __put_user(/* current->thread.error_code */ 0, &sc->error_code);
1516 __put_user(/* current->thread.address */ 0, &sc->fault_address);
1517 __put_user(mask, &sc->oldmask);
43fff238
FB		 1518}
1519
579a97f7 1520static inline abi_ulong
05390248 1521get_sigframe(struct target_sigaction *ka, CPUARMState *regs, int framesize)
43fff238
FB		 1522{
1523 unsigned long sp = regs->regs[13];
1524
43fff238
FB		 1525 /*
1526 * This is the X/Open sanctioned signal stack switching.
1527 */
624f7979 1528 if ((ka->sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp))
a04e134a 1529 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
43fff238
FB		 1530 /*
1531 * ATPCS B01 mandates 8-byte alignment
1532 */
579a97f7 1533 return (sp - framesize) & ~7;
43fff238
FB		 1534}
1535
1536static int
05390248 1537setup_return(CPUARMState *env, struct target_sigaction *ka,
f8b0aa25 1538 abi_ulong *rc, abi_ulong frame_addr, int usig, abi_ulong rc_addr)
43fff238 1539{
624f7979 1540 abi_ulong handler = ka->_sa_handler;
992f48a0 1541 abi_ulong retcode;
75b680e5 1542 int thumb = handler & 1;
964413d9
PM		 1543 uint32_t cpsr = cpsr_read(env);
1544
1545 cpsr &= ~CPSR_IT;
1546 if (thumb) {
1547 cpsr |= CPSR_T;
1548 } else {
1549 cpsr &= ~CPSR_T;
1550 }
43fff238 1551
624f7979
PB		 1552 if (ka->sa_flags & TARGET_SA_RESTORER) {
1553 retcode = ka->sa_restorer;
43fff238
FB		 1554 } else {
1555 unsigned int idx = thumb;
1556
624f7979 1557 if (ka->sa_flags & TARGET_SA_SIGINFO)
43fff238
FB		 1558 idx += 2;
1559
1560 if (__put_user(retcodes[idx], rc))
1561 return 1;
ca8a277c 1562
f8b0aa25 1563 retcode = rc_addr + thumb;
43fff238
FB		 1564 }
1565
1566 env->regs[0] = usig;
f8b0aa25 1567 env->regs[13] = frame_addr;
43fff238
FB		 1568 env->regs[14] = retcode;
1569 env->regs[15] = handler & (thumb ? ~1 : ~3);
964413d9 1570 cpsr_write(env, cpsr, 0xffffffff);
43fff238
FB		 1571
1572 return 0;
1573}
1574
05390248 1575static abi_ulong *setup_sigframe_v2_vfp(abi_ulong *regspace, CPUARMState *env)
0d871bdb
PM		 1576{
1577 int i;
1578 struct target_vfp_sigframe *vfpframe;
1579 vfpframe = (struct target_vfp_sigframe *)regspace;
1580 __put_user(TARGET_VFP_MAGIC, &vfpframe->magic);
1581 __put_user(sizeof(*vfpframe), &vfpframe->size);
1582 for (i = 0; i < 32; i++) {
005e1a0a 1583 __put_user(float64_val(env->vfp.regs[i]), &vfpframe->ufp.fpregs[i]);
0d871bdb
PM		 1584 }
1585 __put_user(vfp_get_fpscr(env), &vfpframe->ufp.fpscr);
1586 __put_user(env->vfp.xregs[ARM_VFP_FPEXC], &vfpframe->ufp_exc.fpexc);
1587 __put_user(env->vfp.xregs[ARM_VFP_FPINST], &vfpframe->ufp_exc.fpinst);
1588 __put_user(env->vfp.xregs[ARM_VFP_FPINST2], &vfpframe->ufp_exc.fpinst2);
1589 return (abi_ulong*)(vfpframe+1);
1590}
1591
05390248
AF		 1592static abi_ulong *setup_sigframe_v2_iwmmxt(abi_ulong *regspace,
1593 CPUARMState *env)
08e11256
PM		 1594{
1595 int i;
1596 struct target_iwmmxt_sigframe *iwmmxtframe;
1597 iwmmxtframe = (struct target_iwmmxt_sigframe *)regspace;
1598 __put_user(TARGET_IWMMXT_MAGIC, &iwmmxtframe->magic);
1599 __put_user(sizeof(*iwmmxtframe), &iwmmxtframe->size);
1600 for (i = 0; i < 16; i++) {
1601 __put_user(env->iwmmxt.regs[i], &iwmmxtframe->regs[i]);
1602 }
1603 __put_user(env->vfp.xregs[ARM_IWMMXT_wCSSF], &iwmmxtframe->wcssf);
1604 __put_user(env->vfp.xregs[ARM_IWMMXT_wCASF], &iwmmxtframe->wcssf);
1605 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR0], &iwmmxtframe->wcgr0);
1606 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR1], &iwmmxtframe->wcgr1);
1607 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR2], &iwmmxtframe->wcgr2);
1608 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR3], &iwmmxtframe->wcgr3);
1609 return (abi_ulong*)(iwmmxtframe+1);
1610}
1611
a8c33204 1612static void setup_sigframe_v2(struct target_ucontext_v2 *uc,
05390248 1613 target_sigset_t *set, CPUARMState *env)
a8c33204
PB		 1614{
1615 struct target_sigaltstack stack;
1616 int i;
0d871bdb 1617 abi_ulong *regspace;
a8c33204
PB		 1618
1619 /* Clear all the bits of the ucontext we don't use. */
1620 memset(uc, 0, offsetof(struct target_ucontext_v2, tuc_mcontext));
1621
1622 memset(&stack, 0, sizeof(stack));
1623 __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp);
1624 __put_user(target_sigaltstack_used.ss_size, &stack.ss_size);
1625 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags);
1626 memcpy(&uc->tuc_stack, &stack, sizeof(stack));
1627
1628 setup_sigcontext(&uc->tuc_mcontext, env, set->sig[0]);
0d871bdb
PM		 1629 /* Save coprocessor signal frame. */
1630 regspace = uc->tuc_regspace;
1631 if (arm_feature(env, ARM_FEATURE_VFP)) {
1632 regspace = setup_sigframe_v2_vfp(regspace, env);
1633 }
08e11256
PM		 1634 if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
1635 regspace = setup_sigframe_v2_iwmmxt(regspace, env);
1636 }
1637
0d871bdb
PM		 1638 /* Write terminating magic word */
1639 __put_user(0, regspace);
1640
a8c33204
PB		 1641 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1642 __put_user(set->sig[i], &uc->tuc_sigmask.sig[i]);
1643 }
1644}
1645
579a97f7 1646/* compare linux/arch/arm/kernel/signal.c:setup_frame() */
624f7979 1647static void setup_frame_v1(int usig, struct target_sigaction *ka,
05390248 1648 target_sigset_t *set, CPUARMState *regs)
43fff238 1649{
a8c33204 1650 struct sigframe_v1 *frame;
579a97f7 1651 abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
a8c33204 1652 int i;
43fff238 1653
579a97f7
FB		 1654 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1655 return;
1656
a8c33204 1657 setup_sigcontext(&frame->sc, regs, set->sig[0]);
43fff238 1658
9231944d
FB		 1659 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1660 if (__put_user(set->sig[i], &frame->extramask[i - 1]))
579a97f7 1661 goto end;
43fff238
FB		 1662 }
1663
a8c33204
PB		 1664 setup_return(regs, ka, &frame->retcode, frame_addr, usig,
1665 frame_addr + offsetof(struct sigframe_v1, retcode));
579a97f7
FB		 1666
1667end:
1668 unlock_user_struct(frame, frame_addr, 1);
a8c33204
PB		 1669}
1670
624f7979 1671static void setup_frame_v2(int usig, struct target_sigaction *ka,
05390248 1672 target_sigset_t *set, CPUARMState *regs)
a8c33204
PB		 1673{
1674 struct sigframe_v2 *frame;
1675 abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
1676
1677 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1678 return;
1679
1680 setup_sigframe_v2(&frame->uc, set, regs);
1681
1682 setup_return(regs, ka, &frame->retcode, frame_addr, usig,
1683 frame_addr + offsetof(struct sigframe_v2, retcode));
1684
1685 unlock_user_struct(frame, frame_addr, 1);
1686}
1687
624f7979 1688static void setup_frame(int usig, struct target_sigaction *ka,
05390248 1689 target_sigset_t *set, CPUARMState *regs)
a8c33204
PB		 1690{
1691 if (get_osversion() >= 0x020612) {
1692 setup_frame_v2(usig, ka, set, regs);
1693 } else {
1694 setup_frame_v1(usig, ka, set, regs);
1695 }
43fff238
FB		 1696}
1697
579a97f7 1698/* compare linux/arch/arm/kernel/signal.c:setup_rt_frame() */
624f7979 1699static void setup_rt_frame_v1(int usig, struct target_sigaction *ka,
c227f099 1700 target_siginfo_t *info,
05390248 1701 target_sigset_t *set, CPUARMState *env)
43fff238 1702{
a745ec6d 1703 struct rt_sigframe_v1 *frame;
579a97f7 1704 abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
a04e134a 1705 struct target_sigaltstack stack;
a8c33204 1706 int i;
f8b0aa25 1707 abi_ulong info_addr, uc_addr;
43fff238 1708
579a97f7 1709 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
edf779ff
FB		 1710 return /* 1 */;
1711
a745ec6d 1712 info_addr = frame_addr + offsetof(struct rt_sigframe_v1, info);
a8c33204 1713 __put_user(info_addr, &frame->pinfo);
a745ec6d 1714 uc_addr = frame_addr + offsetof(struct rt_sigframe_v1, uc);
a8c33204
PB		 1715 __put_user(uc_addr, &frame->puc);
1716 copy_siginfo_to_user(&frame->info, info);
43fff238
FB		 1717
1718 /* Clear all the bits of the ucontext we don't use. */
a745ec6d 1719 memset(&frame->uc, 0, offsetof(struct target_ucontext_v1, tuc_mcontext));
43fff238 1720
a04e134a
TS		 1721 memset(&stack, 0, sizeof(stack));
1722 __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp);
1723 __put_user(target_sigaltstack_used.ss_size, &stack.ss_size);
1724 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags);
775b58d8 1725 memcpy(&frame->uc.tuc_stack, &stack, sizeof(stack));
a04e134a 1726
a8c33204 1727 setup_sigcontext(&frame->uc.tuc_mcontext, env, set->sig[0]);
9231944d 1728 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
b8076a74 1729 if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
579a97f7 1730 goto end;
9231944d 1731 }
43fff238 1732
a8c33204
PB		 1733 setup_return(env, ka, &frame->retcode, frame_addr, usig,
1734 frame_addr + offsetof(struct rt_sigframe_v1, retcode));
a745ec6d 1735
a8c33204
PB		 1736 env->regs[1] = info_addr;
1737 env->regs[2] = uc_addr;
a745ec6d
PB		 1738
1739end:
1740 unlock_user_struct(frame, frame_addr, 1);
a745ec6d
PB		 1741}
1742
624f7979 1743static void setup_rt_frame_v2(int usig, struct target_sigaction *ka,
c227f099 1744 target_siginfo_t *info,
05390248 1745 target_sigset_t *set, CPUARMState *env)
a745ec6d
PB		 1746{
1747 struct rt_sigframe_v2 *frame;
1748 abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
a745ec6d
PB		 1749 abi_ulong info_addr, uc_addr;
1750
1751 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1752 return /* 1 */;
1753
1754 info_addr = frame_addr + offsetof(struct rt_sigframe_v2, info);
1755 uc_addr = frame_addr + offsetof(struct rt_sigframe_v2, uc);
a8c33204 1756 copy_siginfo_to_user(&frame->info, info);
a745ec6d 1757
a8c33204 1758 setup_sigframe_v2(&frame->uc, set, env);
a745ec6d 1759
a8c33204
PB		 1760 setup_return(env, ka, &frame->retcode, frame_addr, usig,
1761 frame_addr + offsetof(struct rt_sigframe_v2, retcode));
a745ec6d 1762
a8c33204
PB		 1763 env->regs[1] = info_addr;
1764 env->regs[2] = uc_addr;
43fff238 1765
579a97f7 1766 unlock_user_struct(frame, frame_addr, 1);
43fff238
FB		 1767}
1768
624f7979 1769static void setup_rt_frame(int usig, struct target_sigaction *ka,
c227f099 1770 target_siginfo_t *info,
05390248 1771 target_sigset_t *set, CPUARMState *env)
a745ec6d
PB		 1772{
1773 if (get_osversion() >= 0x020612) {
1774 setup_rt_frame_v2(usig, ka, info, set, env);
1775 } else {
1776 setup_rt_frame_v1(usig, ka, info, set, env);
1777 }
1778}
1779
43fff238 1780static int
05390248 1781restore_sigcontext(CPUARMState *env, struct target_sigcontext *sc)
43fff238
FB		 1782{
1783 int err = 0;
b5ff1b31 1784 uint32_t cpsr;
43fff238
FB		 1785
1786 __get_user_error(env->regs[0], &sc->arm_r0, err);
1787 __get_user_error(env->regs[1], &sc->arm_r1, err);
1788 __get_user_error(env->regs[2], &sc->arm_r2, err);
1789 __get_user_error(env->regs[3], &sc->arm_r3, err);
1790 __get_user_error(env->regs[4], &sc->arm_r4, err);
1791 __get_user_error(env->regs[5], &sc->arm_r5, err);
1792 __get_user_error(env->regs[6], &sc->arm_r6, err);
1793 __get_user_error(env->regs[7], &sc->arm_r7, err);
1794 __get_user_error(env->regs[8], &sc->arm_r8, err);
1795 __get_user_error(env->regs[9], &sc->arm_r9, err);
1796 __get_user_error(env->regs[10], &sc->arm_r10, err);
1797 __get_user_error(env->regs[11], &sc->arm_fp, err);
1798 __get_user_error(env->regs[12], &sc->arm_ip, err);
1799 __get_user_error(env->regs[13], &sc->arm_sp, err);
1800 __get_user_error(env->regs[14], &sc->arm_lr, err);
1801 __get_user_error(env->regs[15], &sc->arm_pc, err);
1802#ifdef TARGET_CONFIG_CPU_32
b5ff1b31 1803 __get_user_error(cpsr, &sc->arm_cpsr, err);
75b680e5 1804 cpsr_write(env, cpsr, CPSR_USER | CPSR_EXEC);
43fff238
FB		 1805#endif
1806
1807 err |= !valid_user_regs(env);
1808
1809 return err;
1810}
1811
05390248 1812static long do_sigreturn_v1(CPUARMState *env)
43fff238 1813{
f8b0aa25 1814 abi_ulong frame_addr;
978fae9f 1815 struct sigframe_v1 *frame = NULL;
c227f099 1816 target_sigset_t set;
43fff238 1817 sigset_t host_set;
9231944d 1818 int i;
43fff238
FB		 1819
1820 /*
1821 * Since we stacked the signal on a 64-bit boundary,
1822 * then 'sp' should be word aligned here. If it's
1823 * not, then the user is trying to mess with us.
1824 */
f8b0aa25 1825 frame_addr = env->regs[13];
978fae9f
PM		 1826 if (frame_addr & 7) {
1827 goto badframe;
1828 }
1829
f8b0aa25
FB		 1830 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1831 goto badframe;
43fff238 1832
9231944d
FB		 1833 if (__get_user(set.sig[0], &frame->sc.oldmask))
1834 goto badframe;
1835 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1836 if (__get_user(set.sig[i], &frame->extramask[i - 1]))
1837 goto badframe;
1838 }
43fff238 1839
9231944d 1840 target_to_host_sigset_internal(&host_set, &set);
43fff238
FB		 1841 sigprocmask(SIG_SETMASK, &host_set, NULL);
1842
1843 if (restore_sigcontext(env, &frame->sc))
1844 goto badframe;
1845
1846#if 0
1847 /* Send SIGTRAP if we're single-stepping */
1848 if (ptrace_cancel_bpt(current))
1849 send_sig(SIGTRAP, current, 1);
1850#endif
f8b0aa25
FB		 1851 unlock_user_struct(frame, frame_addr, 0);
1852 return env->regs[0];
43fff238
FB		 1853
1854badframe:
f8b0aa25 1855 unlock_user_struct(frame, frame_addr, 0);
66393fb9 1856 force_sig(TARGET_SIGSEGV /* , current */);
43fff238
FB		 1857 return 0;
1858}
1859
05390248 1860static abi_ulong *restore_sigframe_v2_vfp(CPUARMState *env, abi_ulong *regspace)
5f9099d9
PM		 1861{
1862 int i;
1863 abi_ulong magic, sz;
1864 uint32_t fpscr, fpexc;
1865 struct target_vfp_sigframe *vfpframe;
1866 vfpframe = (struct target_vfp_sigframe *)regspace;
1867
1868 __get_user(magic, &vfpframe->magic);
1869 __get_user(sz, &vfpframe->size);
1870 if (magic != TARGET_VFP_MAGIC || sz != sizeof(*vfpframe)) {
1871 return 0;
1872 }
1873 for (i = 0; i < 32; i++) {
005e1a0a 1874 __get_user(float64_val(env->vfp.regs[i]), &vfpframe->ufp.fpregs[i]);
5f9099d9
PM		 1875 }
1876 __get_user(fpscr, &vfpframe->ufp.fpscr);
1877 vfp_set_fpscr(env, fpscr);
1878 __get_user(fpexc, &vfpframe->ufp_exc.fpexc);
1879 /* Sanitise FPEXC: ensure VFP is enabled, FPINST2 is invalid
1880 * and the exception flag is cleared
1881 */
1882 fpexc |= (1 << 30);
1883 fpexc &= ~((1 << 31) | (1 << 28));
1884 env->vfp.xregs[ARM_VFP_FPEXC] = fpexc;
1885 __get_user(env->vfp.xregs[ARM_VFP_FPINST], &vfpframe->ufp_exc.fpinst);
1886 __get_user(env->vfp.xregs[ARM_VFP_FPINST2], &vfpframe->ufp_exc.fpinst2);
1887 return (abi_ulong*)(vfpframe + 1);
1888}
1889
05390248
AF		 1890static abi_ulong *restore_sigframe_v2_iwmmxt(CPUARMState *env,
1891 abi_ulong *regspace)
a59d69da
PM		 1892{
1893 int i;
1894 abi_ulong magic, sz;
1895 struct target_iwmmxt_sigframe *iwmmxtframe;
1896 iwmmxtframe = (struct target_iwmmxt_sigframe *)regspace;
1897
1898 __get_user(magic, &iwmmxtframe->magic);
1899 __get_user(sz, &iwmmxtframe->size);
1900 if (magic != TARGET_IWMMXT_MAGIC || sz != sizeof(*iwmmxtframe)) {
1901 return 0;
1902 }
1903 for (i = 0; i < 16; i++) {
1904 __get_user(env->iwmmxt.regs[i], &iwmmxtframe->regs[i]);
1905 }
1906 __get_user(env->vfp.xregs[ARM_IWMMXT_wCSSF], &iwmmxtframe->wcssf);
1907 __get_user(env->vfp.xregs[ARM_IWMMXT_wCASF], &iwmmxtframe->wcssf);
1908 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR0], &iwmmxtframe->wcgr0);
1909 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR1], &iwmmxtframe->wcgr1);
1910 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR2], &iwmmxtframe->wcgr2);
1911 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR3], &iwmmxtframe->wcgr3);
1912 return (abi_ulong*)(iwmmxtframe + 1);
1913}
1914
05390248 1915static int do_sigframe_return_v2(CPUARMState *env, target_ulong frame_addr,
a8c33204
PB		 1916 struct target_ucontext_v2 *uc)
1917{
1918 sigset_t host_set;
5f9099d9 1919 abi_ulong *regspace;
a8c33204
PB		 1920
1921 target_to_host_sigset(&host_set, &uc->tuc_sigmask);
1922 sigprocmask(SIG_SETMASK, &host_set, NULL);
1923
1924 if (restore_sigcontext(env, &uc->tuc_mcontext))
1925 return 1;
1926
5f9099d9
PM		 1927 /* Restore coprocessor signal frame */
1928 regspace = uc->tuc_regspace;
1929 if (arm_feature(env, ARM_FEATURE_VFP)) {
1930 regspace = restore_sigframe_v2_vfp(env, regspace);
1931 if (!regspace) {
1932 return 1;
1933 }
1934 }
a59d69da
PM		 1935 if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
1936 regspace = restore_sigframe_v2_iwmmxt(env, regspace);
1937 if (!regspace) {
1938 return 1;
1939 }
1940 }
5f9099d9 1941
a8c33204
PB		 1942 if (do_sigaltstack(frame_addr + offsetof(struct target_ucontext_v2, tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT)
1943 return 1;
1944
1945#if 0
1946 /* Send SIGTRAP if we're single-stepping */
1947 if (ptrace_cancel_bpt(current))
1948 send_sig(SIGTRAP, current, 1);
1949#endif
1950
1951 return 0;
1952}
1953
05390248 1954static long do_sigreturn_v2(CPUARMState *env)
a8c33204
PB		 1955{
1956 abi_ulong frame_addr;
978fae9f 1957 struct sigframe_v2 *frame = NULL;
a8c33204
PB		 1958
1959 /*
1960 * Since we stacked the signal on a 64-bit boundary,
1961 * then 'sp' should be word aligned here. If it's
1962 * not, then the user is trying to mess with us.
1963 */
a8c33204 1964 frame_addr = env->regs[13];
978fae9f
PM		 1965 if (frame_addr & 7) {
1966 goto badframe;
1967 }
1968
a8c33204
PB		 1969 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1970 goto badframe;
1971
1972 if (do_sigframe_return_v2(env, frame_addr, &frame->uc))
1973 goto badframe;
1974
1975 unlock_user_struct(frame, frame_addr, 0);
1976 return env->regs[0];
1977
1978badframe:
1979 unlock_user_struct(frame, frame_addr, 0);
66393fb9 1980 force_sig(TARGET_SIGSEGV /* , current */);
a8c33204
PB		 1981 return 0;
1982}
1983
05390248 1984long do_sigreturn(CPUARMState *env)
a8c33204
PB		 1985{
1986 if (get_osversion() >= 0x020612) {
1987 return do_sigreturn_v2(env);
1988 } else {
1989 return do_sigreturn_v1(env);
1990 }
1991}
1992
05390248 1993static long do_rt_sigreturn_v1(CPUARMState *env)
43fff238 1994{
f8b0aa25 1995 abi_ulong frame_addr;
978fae9f 1996 struct rt_sigframe_v1 *frame = NULL;
a745ec6d
PB		 1997 sigset_t host_set;
1998
1999 /*
2000 * Since we stacked the signal on a 64-bit boundary,
2001 * then 'sp' should be word aligned here. If it's
2002 * not, then the user is trying to mess with us.
2003 */
a745ec6d 2004 frame_addr = env->regs[13];
978fae9f
PM		 2005 if (frame_addr & 7) {
2006 goto badframe;
2007 }
2008
a745ec6d
PB		 2009 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
2010 goto badframe;
2011
2012 target_to_host_sigset(&host_set, &frame->uc.tuc_sigmask);
2013 sigprocmask(SIG_SETMASK, &host_set, NULL);
2014
2015 if (restore_sigcontext(env, &frame->uc.tuc_mcontext))
2016 goto badframe;
2017
2018 if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe_v1, uc.tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT)
2019 goto badframe;
2020
2021#if 0
2022 /* Send SIGTRAP if we're single-stepping */
2023 if (ptrace_cancel_bpt(current))
2024 send_sig(SIGTRAP, current, 1);
2025#endif
2026 unlock_user_struct(frame, frame_addr, 0);
2027 return env->regs[0];
2028
2029badframe:
2030 unlock_user_struct(frame, frame_addr, 0);
66393fb9 2031 force_sig(TARGET_SIGSEGV /* , current */);
a745ec6d
PB		 2032 return 0;
2033}
2034
05390248 2035static long do_rt_sigreturn_v2(CPUARMState *env)
a745ec6d
PB		 2036{
2037 abi_ulong frame_addr;
978fae9f 2038 struct rt_sigframe_v2 *frame = NULL;
43fff238
FB		 2039
2040 /*
2041 * Since we stacked the signal on a 64-bit boundary,
2042 * then 'sp' should be word aligned here. If it's
2043 * not, then the user is trying to mess with us.
2044 */
f8b0aa25 2045 frame_addr = env->regs[13];
978fae9f
PM		 2046 if (frame_addr & 7) {
2047 goto badframe;
2048 }
2049
f8b0aa25
FB		 2050 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
2051 goto badframe;
43fff238 2052
a8c33204
PB		 2053 if (do_sigframe_return_v2(env, frame_addr, &frame->uc))
2054 goto badframe;
a04e134a 2055
f8b0aa25 2056 unlock_user_struct(frame, frame_addr, 0);
43fff238
FB		 2057 return env->regs[0];
2058
2059badframe:
f8b0aa25 2060 unlock_user_struct(frame, frame_addr, 0);
66393fb9 2061 force_sig(TARGET_SIGSEGV /* , current */);
43fff238
FB		 2062 return 0;
2063}
2064
05390248 2065long do_rt_sigreturn(CPUARMState *env)
a745ec6d
PB		 2066{
2067 if (get_osversion() >= 0x020612) {
2068 return do_rt_sigreturn_v2(env);
2069 } else {
2070 return do_rt_sigreturn_v1(env);
2071 }
2072}
2073
6d5e216d 2074#elif defined(TARGET_SPARC)
80a9d035 2075
6d5e216d
FB		 2076#define __SUNOS_MAXWIN 31
2077
2078/* This is what SunOS does, so shall I. */
2079struct target_sigcontext {
992f48a0 2080 abi_ulong sigc_onstack; /* state to restore */
6d5e216d 2081
992f48a0
BS		 2082 abi_ulong sigc_mask; /* sigmask to restore */
2083 abi_ulong sigc_sp; /* stack pointer */
2084 abi_ulong sigc_pc; /* program counter */
2085 abi_ulong sigc_npc; /* next program counter */
2086 abi_ulong sigc_psr; /* for condition codes etc */
2087 abi_ulong sigc_g1; /* User uses these two registers */
2088 abi_ulong sigc_o0; /* within the trampoline code. */
6d5e216d
FB		 2089
2090 /* Now comes information regarding the users window set
2091 * at the time of the signal.
2092 */
992f48a0 2093 abi_ulong sigc_oswins; /* outstanding windows */
6d5e216d
FB		 2094
2095 /* stack ptrs for each regwin buf */
2096 char *sigc_spbuf[__SUNOS_MAXWIN];
2097
2098 /* Windows to restore after signal */
2099 struct {
992f48a0
BS		 2100 abi_ulong locals[8];
2101 abi_ulong ins[8];
6d5e216d
FB		 2102 } sigc_wbuf[__SUNOS_MAXWIN];
2103};
2104/* A Sparc stack frame */
2105struct sparc_stackf {
992f48a0 2106 abi_ulong locals[8];
e321c34a
PM		 2107 abi_ulong ins[8];
2108 /* It's simpler to treat fp and callers_pc as elements of ins[]
2109 * since we never need to access them ourselves.
2110 */
6d5e216d 2111 char *structptr;
992f48a0
BS		 2112 abi_ulong xargs[6];
2113 abi_ulong xxargs[1];
6d5e216d
FB		 2114};
2115
2116typedef struct {
2117 struct {
992f48a0
BS		 2118 abi_ulong psr;
2119 abi_ulong pc;
2120 abi_ulong npc;
2121 abi_ulong y;
2122 abi_ulong u_regs[16]; /* globals and ins */
6d5e216d
FB		 2123 } si_regs;
2124 int si_mask;
2125} __siginfo_t;
2126
2127typedef struct {
8954bae3 2128 abi_ulong si_float_regs[32];
6d5e216d
FB		 2129 unsigned long si_fsr;
2130 unsigned long si_fpqdepth;
2131 struct {
2132 unsigned long *insn_addr;
2133 unsigned long insn;
2134 } si_fpqueue [16];
c227f099 2135} qemu_siginfo_fpu_t;
6d5e216d
FB		 2136
2137
2138struct target_signal_frame {
2139 struct sparc_stackf ss;
2140 __siginfo_t info;
f8b0aa25 2141 abi_ulong fpu_save;
992f48a0
BS		 2142 abi_ulong insns[2] __attribute__ ((aligned (8)));
2143 abi_ulong extramask[TARGET_NSIG_WORDS - 1];
2144 abi_ulong extra_size; /* Should be 0 */
c227f099 2145 qemu_siginfo_fpu_t fpu_state;
6d5e216d
FB		 2146};
2147struct target_rt_signal_frame {
2148 struct sparc_stackf ss;
2149 siginfo_t info;
992f48a0 2150 abi_ulong regs[20];
6d5e216d 2151 sigset_t mask;
f8b0aa25 2152 abi_ulong fpu_save;
6d5e216d
FB		 2153 unsigned int insns[2];
2154 stack_t stack;
2155 unsigned int extra_size; /* Should be 0 */
c227f099 2156 qemu_siginfo_fpu_t fpu_state;
6d5e216d
FB		 2157};
2158
e80cfcfc
FB		 2159#define UREG_O0 16
2160#define UREG_O6 22
2161#define UREG_I0 0
2162#define UREG_I1 1
2163#define UREG_I2 2
5bfb56b2
BS		 2164#define UREG_I3 3
2165#define UREG_I4 4
2166#define UREG_I5 5
e80cfcfc
FB		 2167#define UREG_I6 6
2168#define UREG_I7 7
2169#define UREG_L0 8
6d5e216d
FB		 2170#define UREG_FP UREG_I6
2171#define UREG_SP UREG_O6
2172
624f7979 2173static inline abi_ulong get_sigframe(struct target_sigaction *sa,
05390248
AF		 2174 CPUSPARCState *env,
2175 unsigned long framesize)
6d5e216d 2176{
459a4017 2177 abi_ulong sp;
6d5e216d
FB		 2178
2179 sp = env->regwptr[UREG_FP];
6d5e216d
FB		 2180
2181 /* This is the X/Open sanctioned signal stack switching. */
624f7979 2182 if (sa->sa_flags & TARGET_SA_ONSTACK) {
a04e134a
TS		 2183 if (!on_sig_stack(sp)
2184 && !((target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size) & 7))
2185 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
6d5e216d 2186 }
459a4017 2187 return sp - framesize;
6d5e216d
FB		 2188}
2189
2190static int
05390248 2191setup___siginfo(__siginfo_t *si, CPUSPARCState *env, abi_ulong mask)
6d5e216d
FB		 2192{
2193 int err = 0, i;
2194
6d5e216d 2195 err |= __put_user(env->psr, &si->si_regs.psr);
6d5e216d
FB		 2196 err |= __put_user(env->pc, &si->si_regs.pc);
2197 err |= __put_user(env->npc, &si->si_regs.npc);
2198 err |= __put_user(env->y, &si->si_regs.y);
a315a145 2199 for (i=0; i < 8; i++) {
6d5e216d
FB		 2200 err |= __put_user(env->gregs[i], &si->si_regs.u_regs[i]);
2201 }
a315a145 2202 for (i=0; i < 8; i++) {
e80cfcfc 2203 err |= __put_user(env->regwptr[UREG_I0 + i], &si->si_regs.u_regs[i+8]);
6d5e216d 2204 }
6d5e216d
FB		 2205 err |= __put_user(mask, &si->si_mask);
2206 return err;
2207}
e80cfcfc 2208
80a9d035 2209#if 0
6d5e216d
FB		 2210static int
2211setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
05390248 2212 CPUSPARCState *env, unsigned long mask)
6d5e216d
FB		 2213{
2214 int err = 0;
2215
2216 err |= __put_user(mask, &sc->sigc_mask);
2217 err |= __put_user(env->regwptr[UREG_SP], &sc->sigc_sp);
2218 err |= __put_user(env->pc, &sc->sigc_pc);
2219 err |= __put_user(env->npc, &sc->sigc_npc);
2220 err |= __put_user(env->psr, &sc->sigc_psr);
2221 err |= __put_user(env->gregs[1], &sc->sigc_g1);
2222 err |= __put_user(env->regwptr[UREG_O0], &sc->sigc_o0);
2223
2224 return err;
2225}
80a9d035 2226#endif
6d5e216d
FB		 2227#define NF_ALIGNEDSZ (((sizeof(struct target_signal_frame) + 7) & (~7)))
2228
624f7979 2229static void setup_frame(int sig, struct target_sigaction *ka,
05390248 2230 target_sigset_t *set, CPUSPARCState *env)
6d5e216d 2231{
459a4017 2232 abi_ulong sf_addr;
6d5e216d
FB		 2233 struct target_signal_frame *sf;
2234 int sigframe_size, err, i;
2235
2236 /* 1. Make sure everything is clean */
2237 //synchronize_user_stack();
2238
2239 sigframe_size = NF_ALIGNEDSZ;
459a4017 2240 sf_addr = get_sigframe(ka, env, sigframe_size);
6d5e216d 2241
459a4017
FB		 2242 sf = lock_user(VERIFY_WRITE, sf_addr,
2243 sizeof(struct target_signal_frame), 0);
2244 if (!sf)
2245 goto sigsegv;
2246
e80cfcfc 2247 //fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
6d5e216d
FB		 2248#if 0
2249 if (invalid_frame_pointer(sf, sigframe_size))
2250 goto sigill_and_return;
2251#endif
2252 /* 2. Save the current process state */
2253 err = setup___siginfo(&sf->info, env, set->sig[0]);
2254 err |= __put_user(0, &sf->extra_size);
2255
2256 //err |= save_fpu_state(regs, &sf->fpu_state);
2257 //err |= __put_user(&sf->fpu_state, &sf->fpu_save);
2258
2259 err |= __put_user(set->sig[0], &sf->info.si_mask);
2260 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
2261 err |= __put_user(set->sig[i + 1], &sf->extramask[i]);
2262 }
2263
a315a145 2264 for (i = 0; i < 8; i++) {
e80cfcfc 2265 err |= __put_user(env->regwptr[i + UREG_L0], &sf->ss.locals[i]);
6d5e216d 2266 }
a315a145 2267 for (i = 0; i < 8; i++) {
e80cfcfc 2268 err |= __put_user(env->regwptr[i + UREG_I0], &sf->ss.ins[i]);
6d5e216d 2269 }
6d5e216d
FB		 2270 if (err)
2271 goto sigsegv;
2272
2273 /* 3. signal handler back-trampoline and parameters */
459a4017 2274 env->regwptr[UREG_FP] = sf_addr;
6d5e216d 2275 env->regwptr[UREG_I0] = sig;
459a4017
FB		 2276 env->regwptr[UREG_I1] = sf_addr +
2277 offsetof(struct target_signal_frame, info);
2278 env->regwptr[UREG_I2] = sf_addr +
2279 offsetof(struct target_signal_frame, info);
6d5e216d
FB		 2280
2281 /* 4. signal handler */
624f7979 2282 env->pc = ka->_sa_handler;
6d5e216d
FB		 2283 env->npc = (env->pc + 4);
2284 /* 5. return to kernel instructions */
624f7979
PB		 2285 if (ka->sa_restorer)
2286 env->regwptr[UREG_I7] = ka->sa_restorer;
6d5e216d 2287 else {
775b58d8 2288 uint32_t val32;
459a4017
FB		 2289
2290 env->regwptr[UREG_I7] = sf_addr +
2291 offsetof(struct target_signal_frame, insns) - 2 * 4;
6d5e216d
FB		 2292
2293 /* mov __NR_sigreturn, %g1 */
775b58d8
FB		 2294 val32 = 0x821020d8;
2295 err |= __put_user(val32, &sf->insns[0]);
6d5e216d
FB		 2296
2297 /* t 0x10 */
775b58d8
FB		 2298 val32 = 0x91d02010;
2299 err |= __put_user(val32, &sf->insns[1]);
6d5e216d
FB		 2300 if (err)
2301 goto sigsegv;
2302
2303 /* Flush instruction space. */
2304 //flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
80a9d035 2305 // tb_flush(env);
6d5e216d 2306 }
459a4017 2307 unlock_user(sf, sf_addr, sizeof(struct target_signal_frame));
6d5e216d 2308 return;
459a4017
FB		 2309#if 0
2310sigill_and_return:
6d5e216d 2311 force_sig(TARGET_SIGILL);
459a4017 2312#endif
6d5e216d 2313sigsegv:
e80cfcfc 2314 //fprintf(stderr, "force_sig\n");
459a4017 2315 unlock_user(sf, sf_addr, sizeof(struct target_signal_frame));
6d5e216d
FB		 2316 force_sig(TARGET_SIGSEGV);
2317}
2318static inline int
05390248 2319restore_fpu_state(CPUSPARCState *env, qemu_siginfo_fpu_t *fpu)
6d5e216d
FB		 2320{
2321 int err;
2322#if 0
2323#ifdef CONFIG_SMP
2324 if (current->flags & PF_USEDFPU)
2325 regs->psr &= ~PSR_EF;
2326#else
2327 if (current == last_task_used_math) {
2328 last_task_used_math = 0;
2329 regs->psr &= ~PSR_EF;
2330 }
2331#endif
2332 current->used_math = 1;
2333 current->flags &= ~PF_USEDFPU;
2334#endif
2335#if 0
2336 if (verify_area (VERIFY_READ, fpu, sizeof(*fpu)))
2337 return -EFAULT;
2338#endif
2339
fafffaef 2340 /* XXX: incorrect */
8954bae3
BS		 2341 err = copy_from_user(&env->fpr[0], fpu->si_float_regs[0],
2342 (sizeof(abi_ulong) * 32));
6d5e216d
FB		 2343 err |= __get_user(env->fsr, &fpu->si_fsr);
2344#if 0
2345 err |= __get_user(current->thread.fpqdepth, &fpu->si_fpqdepth);
2346 if (current->thread.fpqdepth != 0)
2347 err |= __copy_from_user(&current->thread.fpqueue[0],
2348 &fpu->si_fpqueue[0],
2349 ((sizeof(unsigned long) +
2350 (sizeof(unsigned long *)))*16));
2351#endif
2352 return err;
2353}
2354
2355
624f7979 2356static void setup_rt_frame(int sig, struct target_sigaction *ka,
c227f099 2357 target_siginfo_t *info,
05390248 2358 target_sigset_t *set, CPUSPARCState *env)
6d5e216d
FB		 2359{
2360 fprintf(stderr, "setup_rt_frame: not implemented\n");
2361}
2362
05390248 2363long do_sigreturn(CPUSPARCState *env)
6d5e216d 2364{
f8b0aa25 2365 abi_ulong sf_addr;
6d5e216d 2366 struct target_signal_frame *sf;
e80cfcfc 2367 uint32_t up_psr, pc, npc;
c227f099 2368 target_sigset_t set;
e80cfcfc 2369 sigset_t host_set;
e80cfcfc 2370 int err, i;
6d5e216d 2371
f8b0aa25
FB		 2372 sf_addr = env->regwptr[UREG_FP];
2373 if (!lock_user_struct(VERIFY_READ, sf, sf_addr, 1))
2374 goto segv_and_exit;
80a9d035 2375#if 0
e80cfcfc
FB		 2376 fprintf(stderr, "sigreturn\n");
2377 fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
80a9d035 2378#endif
e80cfcfc 2379 //cpu_dump_state(env, stderr, fprintf, 0);
6d5e216d
FB		 2380
2381 /* 1. Make sure we are not getting garbage from the user */
6d5e216d 2382
f8b0aa25 2383 if (sf_addr & 3)
6d5e216d
FB		 2384 goto segv_and_exit;
2385
2386 err = __get_user(pc, &sf->info.si_regs.pc);
2387 err |= __get_user(npc, &sf->info.si_regs.npc);
2388
6d5e216d
FB		 2389 if ((pc | npc) & 3)
2390 goto segv_and_exit;
2391
2392 /* 2. Restore the state */
e80cfcfc
FB		 2393 err |= __get_user(up_psr, &sf->info.si_regs.psr);
2394
6d5e216d 2395 /* User can only change condition codes and FPU enabling in %psr. */
a315a145
FB		 2396 env->psr = (up_psr & (PSR_ICC /* | PSR_EF */))
2397 | (env->psr & ~(PSR_ICC /* | PSR_EF */));
2398
2399 env->pc = pc;
2400 env->npc = npc;
e80cfcfc 2401 err |= __get_user(env->y, &sf->info.si_regs.y);
a315a145 2402 for (i=0; i < 8; i++) {
e80cfcfc
FB		 2403 err |= __get_user(env->gregs[i], &sf->info.si_regs.u_regs[i]);
2404 }
a315a145 2405 for (i=0; i < 8; i++) {
e80cfcfc
FB		 2406 err |= __get_user(env->regwptr[i + UREG_I0], &sf->info.si_regs.u_regs[i+8]);
2407 }
6d5e216d 2408
2aec3a27
PM		 2409 /* FIXME: implement FPU save/restore:
2410 * __get_user(fpu_save, &sf->fpu_save);
2411 * if (fpu_save)
2412 * err |= restore_fpu_state(env, fpu_save);
2413 */
6d5e216d
FB		 2414
2415 /* This is pretty much atomic, no amount locking would prevent
2416 * the races which exist anyways.
2417 */
2418 err |= __get_user(set.sig[0], &sf->info.si_mask);
e80cfcfc
FB		 2419 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
2420 err |= (__get_user(set.sig[i], &sf->extramask[i - 1]));
2421 }
2422
2423 target_to_host_sigset_internal(&host_set, &set);
2424 sigprocmask(SIG_SETMASK, &host_set, NULL);
6d5e216d
FB		 2425
2426 if (err)
2427 goto segv_and_exit;
f8b0aa25 2428 unlock_user_struct(sf, sf_addr, 0);
6d5e216d
FB		 2429 return env->regwptr[0];
2430
2431segv_and_exit:
f8b0aa25 2432 unlock_user_struct(sf, sf_addr, 0);
6d5e216d
FB		 2433 force_sig(TARGET_SIGSEGV);
2434}
2435
05390248 2436long do_rt_sigreturn(CPUSPARCState *env)
6d5e216d
FB		 2437{
2438 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
f8b0aa25 2439 return -TARGET_ENOSYS;
6d5e216d
FB		 2440}
2441
459a4017 2442#if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
5bfb56b2
BS		 2443#define MC_TSTATE 0
2444#define MC_PC 1
2445#define MC_NPC 2
2446#define MC_Y 3
2447#define MC_G1 4
2448#define MC_G2 5
2449#define MC_G3 6
2450#define MC_G4 7
2451#define MC_G5 8
2452#define MC_G6 9
2453#define MC_G7 10
2454#define MC_O0 11
2455#define MC_O1 12
2456#define MC_O2 13
2457#define MC_O3 14
2458#define MC_O4 15
2459#define MC_O5 16
2460#define MC_O6 17
2461#define MC_O7 18
2462#define MC_NGREG 19
2463
c227f099
AL		 2464typedef abi_ulong target_mc_greg_t;
2465typedef target_mc_greg_t target_mc_gregset_t[MC_NGREG];
5bfb56b2
BS		 2466
2467struct target_mc_fq {
992f48a0 2468 abi_ulong *mcfq_addr;
5bfb56b2
BS		 2469 uint32_t mcfq_insn;
2470};
2471
2472struct target_mc_fpu {
2473 union {
2474 uint32_t sregs[32];
2475 uint64_t dregs[32];
2476 //uint128_t qregs[16];
2477 } mcfpu_fregs;
992f48a0
BS		 2478 abi_ulong mcfpu_fsr;
2479 abi_ulong mcfpu_fprs;
2480 abi_ulong mcfpu_gsr;
5bfb56b2
BS		 2481 struct target_mc_fq *mcfpu_fq;
2482 unsigned char mcfpu_qcnt;
2483 unsigned char mcfpu_qentsz;
2484 unsigned char mcfpu_enab;
2485};
c227f099 2486typedef struct target_mc_fpu target_mc_fpu_t;
5bfb56b2
BS		 2487
2488typedef struct {
c227f099
AL		 2489 target_mc_gregset_t mc_gregs;
2490 target_mc_greg_t mc_fp;
2491 target_mc_greg_t mc_i7;
2492 target_mc_fpu_t mc_fpregs;
2493} target_mcontext_t;
5bfb56b2
BS		 2494
2495struct target_ucontext {
60e99246
AJ		 2496 struct target_ucontext *tuc_link;
2497 abi_ulong tuc_flags;
2498 target_sigset_t tuc_sigmask;
2499 target_mcontext_t tuc_mcontext;
5bfb56b2
BS		 2500};
2501
2502/* A V9 register window */
2503struct target_reg_window {
992f48a0
BS		 2504 abi_ulong locals[8];
2505 abi_ulong ins[8];
5bfb56b2
BS		 2506};
2507
2508#define TARGET_STACK_BIAS 2047
2509
2510/* {set, get}context() needed for 64-bit SparcLinux userland. */
2511void sparc64_set_context(CPUSPARCState *env)
2512{
459a4017
FB		 2513 abi_ulong ucp_addr;
2514 struct target_ucontext *ucp;
c227f099 2515 target_mc_gregset_t *grp;
992f48a0 2516 abi_ulong pc, npc, tstate;
459a4017 2517 abi_ulong fp, i7, w_addr;
5bfb56b2
BS		 2518 int err;
2519 unsigned int i;
5bfb56b2 2520
459a4017
FB		 2521 ucp_addr = env->regwptr[UREG_I0];
2522 if (!lock_user_struct(VERIFY_READ, ucp, ucp_addr, 1))
2523 goto do_sigsegv;
60e99246 2524 grp = &ucp->tuc_mcontext.mc_gregs;
579a97f7
FB		 2525 err = __get_user(pc, &((*grp)[MC_PC]));
2526 err |= __get_user(npc, &((*grp)[MC_NPC]));
5bfb56b2
BS		 2527 if (err || ((pc | npc) & 3))
2528 goto do_sigsegv;
2529 if (env->regwptr[UREG_I1]) {
c227f099 2530 target_sigset_t target_set;
5bfb56b2
BS		 2531 sigset_t set;
2532
2533 if (TARGET_NSIG_WORDS == 1) {
60e99246 2534 if (__get_user(target_set.sig[0], &ucp->tuc_sigmask.sig[0]))
5bfb56b2
BS		 2535 goto do_sigsegv;
2536 } else {
459a4017 2537 abi_ulong *src, *dst;
60e99246 2538 src = ucp->tuc_sigmask.sig;
459a4017 2539 dst = target_set.sig;
c227f099 2540 for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong);
5bfb56b2 2541 i++, dst++, src++)
459a4017 2542 err |= __get_user(*dst, src);
5bfb56b2
BS		 2543 if (err)
2544 goto do_sigsegv;
2545 }
2546 target_to_host_sigset_internal(&set, &target_set);
2547 sigprocmask(SIG_SETMASK, &set, NULL);
2548 }
2549 env->pc = pc;
2550 env->npc = npc;
579a97f7
FB		 2551 err |= __get_user(env->y, &((*grp)[MC_Y]));
2552 err |= __get_user(tstate, &((*grp)[MC_TSTATE]));
5bfb56b2 2553 env->asi = (tstate >> 24) & 0xff;
5a834bb4
BS		 2554 cpu_put_ccr(env, tstate >> 32);
2555 cpu_put_cwp64(env, tstate & 0x1f);
579a97f7
FB		 2556 err |= __get_user(env->gregs[1], (&(*grp)[MC_G1]));
2557 err |= __get_user(env->gregs[2], (&(*grp)[MC_G2]));
2558 err |= __get_user(env->gregs[3], (&(*grp)[MC_G3]));
2559 err |= __get_user(env->gregs[4], (&(*grp)[MC_G4]));
2560 err |= __get_user(env->gregs[5], (&(*grp)[MC_G5]));
2561 err |= __get_user(env->gregs[6], (&(*grp)[MC_G6]));
2562 err |= __get_user(env->gregs[7], (&(*grp)[MC_G7]));
2563 err |= __get_user(env->regwptr[UREG_I0], (&(*grp)[MC_O0]));
2564 err |= __get_user(env->regwptr[UREG_I1], (&(*grp)[MC_O1]));
2565 err |= __get_user(env->regwptr[UREG_I2], (&(*grp)[MC_O2]));
2566 err |= __get_user(env->regwptr[UREG_I3], (&(*grp)[MC_O3]));
2567 err |= __get_user(env->regwptr[UREG_I4], (&(*grp)[MC_O4]));
2568 err |= __get_user(env->regwptr[UREG_I5], (&(*grp)[MC_O5]));
2569 err |= __get_user(env->regwptr[UREG_I6], (&(*grp)[MC_O6]));
2570 err |= __get_user(env->regwptr[UREG_I7], (&(*grp)[MC_O7]));
2571
60e99246
AJ		 2572 err |= __get_user(fp, &(ucp->tuc_mcontext.mc_fp));
2573 err |= __get_user(i7, &(ucp->tuc_mcontext.mc_i7));
579a97f7 2574
459a4017
FB		 2575 w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
2576 if (put_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]),
2577 abi_ulong) != 0)
2578 goto do_sigsegv;
2579 if (put_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]),
2580 abi_ulong) != 0)
2581 goto do_sigsegv;
c7b016ba
PM		 2582 /* FIXME this does not match how the kernel handles the FPU in
2583 * its sparc64_set_context implementation. In particular the FPU
2584 * is only restored if fenab is non-zero in:
2585 * __get_user(fenab, &(ucp->tuc_mcontext.mc_fpregs.mcfpu_enab));
2586 */
60e99246 2587 err |= __get_user(env->fprs, &(ucp->tuc_mcontext.mc_fpregs.mcfpu_fprs));
459a4017 2588 {
30038fd8
RH		 2589 uint32_t *src = ucp->tuc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2590 for (i = 0; i < 64; i++, src++) {
2591 if (i & 1) {
2592 err |= __get_user(env->fpr[i/2].l.lower, src);
2593 } else {
2594 err |= __get_user(env->fpr[i/2].l.upper, src);
2595 }
2596 }
459a4017 2597 }
579a97f7 2598 err |= __get_user(env->fsr,
60e99246 2599 &(ucp->tuc_mcontext.mc_fpregs.mcfpu_fsr));
579a97f7 2600 err |= __get_user(env->gsr,
60e99246 2601 &(ucp->tuc_mcontext.mc_fpregs.mcfpu_gsr));
5bfb56b2
BS		 2602 if (err)
2603 goto do_sigsegv;
459a4017 2604 unlock_user_struct(ucp, ucp_addr, 0);
5bfb56b2
BS		 2605 return;
2606 do_sigsegv:
459a4017 2607 unlock_user_struct(ucp, ucp_addr, 0);
66393fb9 2608 force_sig(TARGET_SIGSEGV);
5bfb56b2
BS		 2609}
2610
2611void sparc64_get_context(CPUSPARCState *env)
2612{
459a4017
FB		 2613 abi_ulong ucp_addr;
2614 struct target_ucontext *ucp;
c227f099
AL		 2615 target_mc_gregset_t *grp;
2616 target_mcontext_t *mcp;
459a4017 2617 abi_ulong fp, i7, w_addr;
5bfb56b2
BS		 2618 int err;
2619 unsigned int i;
c227f099 2620 target_sigset_t target_set;
5bfb56b2
BS		 2621 sigset_t set;
2622
459a4017
FB		 2623 ucp_addr = env->regwptr[UREG_I0];
2624 if (!lock_user_struct(VERIFY_WRITE, ucp, ucp_addr, 0))
2625 goto do_sigsegv;
2626
60e99246 2627 mcp = &ucp->tuc_mcontext;
5bfb56b2
BS		 2628 grp = &mcp->mc_gregs;
2629
2630 /* Skip over the trap instruction, first. */
2631 env->pc = env->npc;
2632 env->npc += 4;
2633
2634 err = 0;
2635
2636 sigprocmask(0, NULL, &set);
2637 host_to_target_sigset_internal(&target_set, &set);
459a4017 2638 if (TARGET_NSIG_WORDS == 1) {
579a97f7 2639 err |= __put_user(target_set.sig[0],
60e99246 2640 (abi_ulong *)&ucp->tuc_sigmask);
459a4017
FB		 2641 } else {
2642 abi_ulong *src, *dst;
2643 src = target_set.sig;
60e99246 2644 dst = ucp->tuc_sigmask.sig;
c227f099 2645 for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong);
5bfb56b2 2646 i++, dst++, src++)
459a4017 2647 err |= __put_user(*src, dst);
5bfb56b2
BS		 2648 if (err)
2649 goto do_sigsegv;
2650 }
2651
459a4017
FB		 2652 /* XXX: tstate must be saved properly */
2653 // err |= __put_user(env->tstate, &((*grp)[MC_TSTATE]));
579a97f7
FB		 2654 err |= __put_user(env->pc, &((*grp)[MC_PC]));
2655 err |= __put_user(env->npc, &((*grp)[MC_NPC]));
2656 err |= __put_user(env->y, &((*grp)[MC_Y]));
2657 err |= __put_user(env->gregs[1], &((*grp)[MC_G1]));
2658 err |= __put_user(env->gregs[2], &((*grp)[MC_G2]));
2659 err |= __put_user(env->gregs[3], &((*grp)[MC_G3]));
2660 err |= __put_user(env->gregs[4], &((*grp)[MC_G4]));
2661 err |= __put_user(env->gregs[5], &((*grp)[MC_G5]));
2662 err |= __put_user(env->gregs[6], &((*grp)[MC_G6]));
2663 err |= __put_user(env->gregs[7], &((*grp)[MC_G7]));
2664 err |= __put_user(env->regwptr[UREG_I0], &((*grp)[MC_O0]));
2665 err |= __put_user(env->regwptr[UREG_I1], &((*grp)[MC_O1]));
2666 err |= __put_user(env->regwptr[UREG_I2], &((*grp)[MC_O2]));
2667 err |= __put_user(env->regwptr[UREG_I3], &((*grp)[MC_O3]));
2668 err |= __put_user(env->regwptr[UREG_I4], &((*grp)[MC_O4]));
2669 err |= __put_user(env->regwptr[UREG_I5], &((*grp)[MC_O5]));
2670 err |= __put_user(env->regwptr[UREG_I6], &((*grp)[MC_O6]));
2671 err |= __put_user(env->regwptr[UREG_I7], &((*grp)[MC_O7]));
2672
459a4017
FB		 2673 w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
2674 fp = i7 = 0;
2675 if (get_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]),
2676 abi_ulong) != 0)
2677 goto do_sigsegv;
2678 if (get_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]),
2679 abi_ulong) != 0)
2680 goto do_sigsegv;
579a97f7
FB		 2681 err |= __put_user(fp, &(mcp->mc_fp));
2682 err |= __put_user(i7, &(mcp->mc_i7));
5bfb56b2 2683
459a4017 2684 {
30038fd8
RH		 2685 uint32_t *dst = ucp->tuc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2686 for (i = 0; i < 64; i++, dst++) {
2687 if (i & 1) {
2688 err |= __put_user(env->fpr[i/2].l.lower, dst);
2689 } else {
2690 err |= __put_user(env->fpr[i/2].l.upper, dst);
2691 }
2692 }
459a4017 2693 }
579a97f7
FB		 2694 err |= __put_user(env->fsr, &(mcp->mc_fpregs.mcfpu_fsr));
2695 err |= __put_user(env->gsr, &(mcp->mc_fpregs.mcfpu_gsr));
2696 err |= __put_user(env->fprs, &(mcp->mc_fpregs.mcfpu_fprs));
5bfb56b2
BS		 2697
2698 if (err)
2699 goto do_sigsegv;
459a4017 2700 unlock_user_struct(ucp, ucp_addr, 1);
5bfb56b2
BS		 2701 return;
2702 do_sigsegv:
459a4017 2703 unlock_user_struct(ucp, ucp_addr, 1);
66393fb9 2704 force_sig(TARGET_SIGSEGV);
5bfb56b2
BS		 2705}
2706#endif
ff970904 2707#elif defined(TARGET_MIPS) || defined(TARGET_MIPS64)
106ec879 2708
ff970904 2709# if defined(TARGET_ABI_MIPSO32)
106ec879
FB		 2710struct target_sigcontext {
2711 uint32_t sc_regmask; /* Unused */
2712 uint32_t sc_status;
2713 uint64_t sc_pc;
2714 uint64_t sc_regs[32];
2715 uint64_t sc_fpregs[32];
2716 uint32_t sc_ownedfp; /* Unused */
2717 uint32_t sc_fpc_csr;
2718 uint32_t sc_fpc_eir; /* Unused */
2719 uint32_t sc_used_math;
2720 uint32_t sc_dsp; /* dsp status, was sc_ssflags */
94c5495d 2721 uint32_t pad0;
106ec879
FB		 2722 uint64_t sc_mdhi;
2723 uint64_t sc_mdlo;
2724 target_ulong sc_hi1; /* Was sc_cause */
2725 target_ulong sc_lo1; /* Was sc_badvaddr */
2726 target_ulong sc_hi2; /* Was sc_sigset[4] */
2727 target_ulong sc_lo2;
2728 target_ulong sc_hi3;
2729 target_ulong sc_lo3;
2730};
ff970904
RH		 2731# else /* N32 || N64 */
2732struct target_sigcontext {
2733 uint64_t sc_regs[32];
2734 uint64_t sc_fpregs[32];
2735 uint64_t sc_mdhi;
2736 uint64_t sc_hi1;
2737 uint64_t sc_hi2;
2738 uint64_t sc_hi3;
2739 uint64_t sc_mdlo;
2740 uint64_t sc_lo1;
2741 uint64_t sc_lo2;
2742 uint64_t sc_lo3;
2743 uint64_t sc_pc;
2744 uint32_t sc_fpc_csr;
2745 uint32_t sc_used_math;
2746 uint32_t sc_dsp;
2747 uint32_t sc_reserved;
2748};
2749# endif /* O32 */
106ec879
FB		 2750
2751struct sigframe {
2752 uint32_t sf_ass[4]; /* argument save space for o32 */
2753 uint32_t sf_code[2]; /* signal trampoline */
2754 struct target_sigcontext sf_sc;
c227f099 2755 target_sigset_t sf_mask;
106ec879
FB		 2756};
2757
0b1bcb00 2758struct target_ucontext {
60e99246
AJ		 2759 target_ulong tuc_flags;
2760 target_ulong tuc_link;
2761 target_stack_t tuc_stack;
94c5495d 2762 target_ulong pad0;
60e99246
AJ		 2763 struct target_sigcontext tuc_mcontext;
2764 target_sigset_t tuc_sigmask;
0b1bcb00
PB		 2765};
2766
2767struct target_rt_sigframe {
2768 uint32_t rs_ass[4]; /* argument save space for o32 */
2769 uint32_t rs_code[2]; /* signal trampoline */
2770 struct target_siginfo rs_info;
2771 struct target_ucontext rs_uc;
2772};
2773
106ec879
FB		 2774/* Install trampoline to jump back from signal handler */
2775static inline int install_sigtramp(unsigned int *tramp, unsigned int syscall)
2776{
084d0497 2777 int err = 0;
106ec879
FB		 2778
2779 /*
084d0497
RH		 2780 * Set up the return code ...
2781 *
2782 * li v0, __NR__foo_sigreturn
2783 * syscall
2784 */
106ec879 2785
084d0497 2786 err |= __put_user(0x24020000 + syscall, tramp + 0);
106ec879 2787 err |= __put_user(0x0000000c , tramp + 1);
106ec879
FB		 2788 return err;
2789}
2790
2791static inline int
05390248 2792setup_sigcontext(CPUMIPSState *regs, struct target_sigcontext *sc)
106ec879
FB		 2793{
2794 int err = 0;
084d0497 2795 int i;
106ec879 2796
1239b472
KCY		 2797 err |= __put_user(exception_resume_pc(regs), &sc->sc_pc);
2798 regs->hflags &= ~MIPS_HFLAG_BMASK;
106ec879 2799
084d0497
RH		 2800 __put_user(0, &sc->sc_regs[0]);
2801 for (i = 1; i < 32; ++i) {
2802 err |= __put_user(regs->active_tc.gpr[i], &sc->sc_regs[i]);
2803 }
106ec879 2804
b5dc7732
TS		 2805 err |= __put_user(regs->active_tc.HI[0], &sc->sc_mdhi);
2806 err |= __put_user(regs->active_tc.LO[0], &sc->sc_mdlo);
106ec879 2807
084d0497
RH		 2808 /* Rather than checking for dsp existence, always copy. The storage
2809 would just be garbage otherwise. */
2810 err |= __put_user(regs->active_tc.HI[1], &sc->sc_hi1);
2811 err |= __put_user(regs->active_tc.HI[2], &sc->sc_hi2);
2812 err |= __put_user(regs->active_tc.HI[3], &sc->sc_hi3);
2813 err |= __put_user(regs->active_tc.LO[1], &sc->sc_lo1);
2814 err |= __put_user(regs->active_tc.LO[2], &sc->sc_lo2);
2815 err |= __put_user(regs->active_tc.LO[3], &sc->sc_lo3);
2816 {
2817 uint32_t dsp = cpu_rddsp(0x3ff, regs);
2818 err |= __put_user(dsp, &sc->sc_dsp);
106ec879 2819 }
106ec879 2820
084d0497 2821 err |= __put_user(1, &sc->sc_used_math);
106ec879 2822
084d0497
RH		 2823 for (i = 0; i < 32; ++i) {
2824 err |= __put_user(regs->active_fpu.fpr[i].d, &sc->sc_fpregs[i]);
106ec879 2825 }
106ec879 2826
106ec879
FB		 2827 return err;
2828}
2829
2830static inline int
05390248 2831restore_sigcontext(CPUMIPSState *regs, struct target_sigcontext *sc)
106ec879
FB		 2832{
2833 int err = 0;
084d0497 2834 int i;
106ec879
FB		 2835
2836 err |= __get_user(regs->CP0_EPC, &sc->sc_pc);
2837
b5dc7732
TS		 2838 err |= __get_user(regs->active_tc.HI[0], &sc->sc_mdhi);
2839 err |= __get_user(regs->active_tc.LO[0], &sc->sc_mdlo);
106ec879 2840
084d0497
RH		 2841 for (i = 1; i < 32; ++i) {
2842 err |= __get_user(regs->active_tc.gpr[i], &sc->sc_regs[i]);
106ec879 2843 }
106ec879 2844
084d0497
RH		 2845 err |= __get_user(regs->active_tc.HI[1], &sc->sc_hi1);
2846 err |= __get_user(regs->active_tc.HI[2], &sc->sc_hi2);
2847 err |= __get_user(regs->active_tc.HI[3], &sc->sc_hi3);
2848 err |= __get_user(regs->active_tc.LO[1], &sc->sc_lo1);
2849 err |= __get_user(regs->active_tc.LO[2], &sc->sc_lo2);
2850 err |= __get_user(regs->active_tc.LO[3], &sc->sc_lo3);
2851 {
2852 uint32_t dsp;
2853 err |= __get_user(dsp, &sc->sc_dsp);
2854 cpu_wrdsp(dsp, 0x3ff, regs);
2855 }
106ec879 2856
084d0497
RH		 2857 for (i = 0; i < 32; ++i) {
2858 err |= __get_user(regs->active_fpu.fpr[i].d, &sc->sc_fpregs[i]);
106ec879
FB		 2859 }
2860
106ec879
FB		 2861 return err;
2862}
ff970904 2863
106ec879
FB		 2864/*
2865 * Determine which stack to use..
2866 */
579a97f7 2867static inline abi_ulong
05390248 2868get_sigframe(struct target_sigaction *ka, CPUMIPSState *regs, size_t frame_size)
106ec879
FB		 2869{
2870 unsigned long sp;
2871
2872 /* Default to using normal stack */
b5dc7732 2873 sp = regs->active_tc.gpr[29];
106ec879
FB		 2874
2875 /*
93148aa5 2876 * FPU emulator may have its own trampoline active just
106ec879
FB		 2877 * above the user stack, 16-bytes before the next lowest
2878 * 16 byte boundary. Try to avoid trashing it.
2879 */
2880 sp -= 32;
2881
106ec879 2882 /* This is the X/Open sanctioned signal stack switching. */
624f7979 2883 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) {
a04e134a
TS		 2884 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
2885 }
106ec879 2886
579a97f7 2887 return (sp - frame_size) & ~7;
106ec879
FB		 2888}
2889
ea3164aa
KCY		 2890static void mips_set_hflags_isa_mode_from_pc(CPUMIPSState *env)
2891{
2892 if (env->insn_flags & (ASE_MIPS16 | ASE_MICROMIPS)) {
2893 env->hflags &= ~MIPS_HFLAG_M16;
2894 env->hflags |= (env->active_tc.PC & 1) << MIPS_HFLAG_M16_SHIFT;
2895 env->active_tc.PC &= ~(target_ulong) 1;
2896 }
2897}
2898
ff970904 2899# if defined(TARGET_ABI_MIPSO32)
579a97f7 2900/* compare linux/arch/mips/kernel/signal.c:setup_frame() */
624f7979 2901static void setup_frame(int sig, struct target_sigaction * ka,
05390248 2902 target_sigset_t *set, CPUMIPSState *regs)
106ec879
FB		 2903{
2904 struct sigframe *frame;
579a97f7 2905 abi_ulong frame_addr;
106ec879
FB		 2906 int i;
2907
579a97f7
FB		 2908 frame_addr = get_sigframe(ka, regs, sizeof(*frame));
2909 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
106ec879
FB		 2910 goto give_sigsegv;
2911
2912 install_sigtramp(frame->sf_code, TARGET_NR_sigreturn);
2913
2914 if(setup_sigcontext(regs, &frame->sf_sc))
2915 goto give_sigsegv;
2916
2917 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2918 if(__put_user(set->sig[i], &frame->sf_mask.sig[i]))
2919 goto give_sigsegv;
2920 }
2921
2922 /*
2923 * Arguments to signal handler:
2924 *
2925 * a0 = signal number
2926 * a1 = 0 (should be cause)
2927 * a2 = pointer to struct sigcontext
2928 *
2929 * $25 and PC point to the signal handler, $29 points to the
2930 * struct sigframe.
2931 */
b5dc7732
TS		 2932 regs->active_tc.gpr[ 4] = sig;
2933 regs->active_tc.gpr[ 5] = 0;
2934 regs->active_tc.gpr[ 6] = frame_addr + offsetof(struct sigframe, sf_sc);
2935 regs->active_tc.gpr[29] = frame_addr;
2936 regs->active_tc.gpr[31] = frame_addr + offsetof(struct sigframe, sf_code);
106ec879
FB		 2937 /* The original kernel code sets CP0_EPC to the handler
2938 * since it returns to userland using eret
2939 * we cannot do this here, and we must set PC directly */
b5dc7732 2940 regs->active_tc.PC = regs->active_tc.gpr[25] = ka->_sa_handler;
ea3164aa 2941 mips_set_hflags_isa_mode_from_pc(regs);
579a97f7 2942 unlock_user_struct(frame, frame_addr, 1);
106ec879
FB		 2943 return;
2944
2945give_sigsegv:
579a97f7 2946 unlock_user_struct(frame, frame_addr, 1);
106ec879 2947 force_sig(TARGET_SIGSEGV/*, current*/);
106ec879
FB		 2948}
2949
05390248 2950long do_sigreturn(CPUMIPSState *regs)
106ec879 2951{
388bb21a 2952 struct sigframe *frame;
579a97f7 2953 abi_ulong frame_addr;
388bb21a 2954 sigset_t blocked;
c227f099 2955 target_sigset_t target_set;
388bb21a 2956 int i;
106ec879
FB		 2957
2958#if defined(DEBUG_SIGNAL)
388bb21a 2959 fprintf(stderr, "do_sigreturn\n");
106ec879 2960#endif
b5dc7732 2961 frame_addr = regs->active_tc.gpr[29];
579a97f7 2962 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
106ec879
FB		 2963 goto badframe;
2964
388bb21a 2965 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
106ec879
FB		 2966 if(__get_user(target_set.sig[i], &frame->sf_mask.sig[i]))
2967 goto badframe;
388bb21a 2968 }
106ec879 2969
388bb21a
TS		 2970 target_to_host_sigset_internal(&blocked, &target_set);
2971 sigprocmask(SIG_SETMASK, &blocked, NULL);
106ec879 2972
388bb21a 2973 if (restore_sigcontext(regs, &frame->sf_sc))
106ec879
FB		 2974 goto badframe;
2975
2976#if 0
388bb21a
TS		 2977 /*
2978 * Don't let your children do this ...
2979 */
2980 __asm__ __volatile__(
106ec879
FB		 2981 "move\t$29, %0\n\t"
2982 "j\tsyscall_exit"
2983 :/* no outputs */
2984 :"r" (&regs));
388bb21a 2985 /* Unreached */
106ec879 2986#endif
3b46e624 2987
b5dc7732 2988 regs->active_tc.PC = regs->CP0_EPC;
ea3164aa 2989 mips_set_hflags_isa_mode_from_pc(regs);
388bb21a 2990 /* I am not sure this is right, but it seems to work
106ec879
FB		 2991 * maybe a problem with nested signals ? */
2992 regs->CP0_EPC = 0;
0b1bcb00 2993 return -TARGET_QEMU_ESIGRETURN;
106ec879
FB		 2994
2995badframe:
388bb21a
TS		 2996 force_sig(TARGET_SIGSEGV/*, current*/);
2997 return 0;
106ec879 2998}
ff970904 2999# endif /* O32 */
106ec879 3000
624f7979 3001static void setup_rt_frame(int sig, struct target_sigaction *ka,
c227f099 3002 target_siginfo_t *info,
05390248 3003 target_sigset_t *set, CPUMIPSState *env)
106ec879 3004{
0b1bcb00
PB		 3005 struct target_rt_sigframe *frame;
3006 abi_ulong frame_addr;
3007 int i;
3008
3009 frame_addr = get_sigframe(ka, env, sizeof(*frame));
3010 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3011 goto give_sigsegv;
3012
3013 install_sigtramp(frame->rs_code, TARGET_NR_rt_sigreturn);
3014
3015 copy_siginfo_to_user(&frame->rs_info, info);
3016
60e99246
AJ		 3017 __put_user(0, &frame->rs_uc.tuc_flags);
3018 __put_user(0, &frame->rs_uc.tuc_link);
3019 __put_user(target_sigaltstack_used.ss_sp, &frame->rs_uc.tuc_stack.ss_sp);
3020 __put_user(target_sigaltstack_used.ss_size, &frame->rs_uc.tuc_stack.ss_size);
0b1bcb00 3021 __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
60e99246 3022 &frame->rs_uc.tuc_stack.ss_flags);
0b1bcb00 3023
60e99246 3024 setup_sigcontext(env, &frame->rs_uc.tuc_mcontext);
0b1bcb00
PB		 3025
3026 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
60e99246 3027 __put_user(set->sig[i], &frame->rs_uc.tuc_sigmask.sig[i]);
0b1bcb00
PB		 3028 }
3029
3030 /*
3031 * Arguments to signal handler:
3032 *
3033 * a0 = signal number
02d2bd5d 3034 * a1 = pointer to siginfo_t
0b1bcb00
PB		 3035 * a2 = pointer to struct ucontext
3036 *
3037 * $25 and PC point to the signal handler, $29 points to the
3038 * struct sigframe.
3039 */
3040 env->active_tc.gpr[ 4] = sig;
3041 env->active_tc.gpr[ 5] = frame_addr
3042 + offsetof(struct target_rt_sigframe, rs_info);
3043 env->active_tc.gpr[ 6] = frame_addr
3044 + offsetof(struct target_rt_sigframe, rs_uc);
3045 env->active_tc.gpr[29] = frame_addr;
3046 env->active_tc.gpr[31] = frame_addr
3047 + offsetof(struct target_rt_sigframe, rs_code);
3048 /* The original kernel code sets CP0_EPC to the handler
3049 * since it returns to userland using eret
3050 * we cannot do this here, and we must set PC directly */
3051 env->active_tc.PC = env->active_tc.gpr[25] = ka->_sa_handler;
ea3164aa 3052 mips_set_hflags_isa_mode_from_pc(env);
0b1bcb00
PB		 3053 unlock_user_struct(frame, frame_addr, 1);
3054 return;
3055
3056give_sigsegv:
3057 unlock_user_struct(frame, frame_addr, 1);
3058 force_sig(TARGET_SIGSEGV/*, current*/);
106ec879
FB		 3059}
3060
05390248 3061long do_rt_sigreturn(CPUMIPSState *env)
106ec879 3062{
0b1bcb00
PB		 3063 struct target_rt_sigframe *frame;
3064 abi_ulong frame_addr;
3065 sigset_t blocked;
3066
3067#if defined(DEBUG_SIGNAL)
3068 fprintf(stderr, "do_rt_sigreturn\n");
3069#endif
3070 frame_addr = env->active_tc.gpr[29];
3071 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
3072 goto badframe;
3073
60e99246 3074 target_to_host_sigset(&blocked, &frame->rs_uc.tuc_sigmask);
0b1bcb00
PB		 3075 sigprocmask(SIG_SETMASK, &blocked, NULL);
3076
60e99246 3077 if (restore_sigcontext(env, &frame->rs_uc.tuc_mcontext))
0b1bcb00
PB		 3078 goto badframe;
3079
3080 if (do_sigaltstack(frame_addr +
60e99246 3081 offsetof(struct target_rt_sigframe, rs_uc.tuc_stack),
0b1bcb00
PB		 3082 0, get_sp_from_cpustate(env)) == -EFAULT)
3083 goto badframe;
3084
3085 env->active_tc.PC = env->CP0_EPC;
ea3164aa 3086 mips_set_hflags_isa_mode_from_pc(env);
0b1bcb00
PB		 3087 /* I am not sure this is right, but it seems to work
3088 * maybe a problem with nested signals ? */
3089 env->CP0_EPC = 0;
3090 return -TARGET_QEMU_ESIGRETURN;
3091
3092badframe:
3093 force_sig(TARGET_SIGSEGV/*, current*/);
3094 return 0;
106ec879 3095}
6d5e216d 3096
c3b5bc8a
TS		 3097#elif defined(TARGET_SH4)
3098
3099/*
3100 * code and data structures from linux kernel:
3101 * include/asm-sh/sigcontext.h
3102 * arch/sh/kernel/signal.c
3103 */
3104
3105struct target_sigcontext {
3106 target_ulong oldmask;
3107
3108 /* CPU registers */
3109 target_ulong sc_gregs[16];
3110 target_ulong sc_pc;
3111 target_ulong sc_pr;
3112 target_ulong sc_sr;
3113 target_ulong sc_gbr;
3114 target_ulong sc_mach;
3115 target_ulong sc_macl;
3116
3117 /* FPU registers */
3118 target_ulong sc_fpregs[16];
3119 target_ulong sc_xfpregs[16];
3120 unsigned int sc_fpscr;
3121 unsigned int sc_fpul;
3122 unsigned int sc_ownedfp;
3123};
3124
3125struct target_sigframe
3126{
3127 struct target_sigcontext sc;
3128 target_ulong extramask[TARGET_NSIG_WORDS-1];
3129 uint16_t retcode[3];
3130};
3131
3132
3133struct target_ucontext {
60e99246
AJ		 3134 target_ulong tuc_flags;
3135 struct target_ucontext *tuc_link;
3136 target_stack_t tuc_stack;
3137 struct target_sigcontext tuc_mcontext;
3138 target_sigset_t tuc_sigmask; /* mask last for extensibility */
c3b5bc8a
TS		 3139};
3140
3141struct target_rt_sigframe
3142{
3143 struct target_siginfo info;
3144 struct target_ucontext uc;
3145 uint16_t retcode[3];
3146};
3147
3148
3149#define MOVW(n) (0x9300|((n)-2)) /* Move mem word at PC+n to R3 */
3150#define TRAP_NOARG 0xc310 /* Syscall w/no args (NR in R3) SH3/4 */
3151
624f7979 3152static abi_ulong get_sigframe(struct target_sigaction *ka,
c3b5bc8a
TS		 3153 unsigned long sp, size_t frame_size)
3154{
624f7979 3155 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags(sp) == 0)) {
c3b5bc8a
TS		 3156 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
3157 }
3158
3159 return (sp - frame_size) & -8ul;
3160}
3161
3162static int setup_sigcontext(struct target_sigcontext *sc,
05390248 3163 CPUSH4State *regs, unsigned long mask)
c3b5bc8a
TS		 3164{
3165 int err = 0;
d8714436 3166 int i;
c3b5bc8a
TS		 3167
3168#define COPY(x) err |= __put_user(regs->x, &sc->sc_##x)
3169 COPY(gregs[0]); COPY(gregs[1]);
3170 COPY(gregs[2]); COPY(gregs[3]);
3171 COPY(gregs[4]); COPY(gregs[5]);
3172 COPY(gregs[6]); COPY(gregs[7]);
3173 COPY(gregs[8]); COPY(gregs[9]);
3174 COPY(gregs[10]); COPY(gregs[11]);
3175 COPY(gregs[12]); COPY(gregs[13]);
3176 COPY(gregs[14]); COPY(gregs[15]);
3177 COPY(gbr); COPY(mach);
3178 COPY(macl); COPY(pr);
3179 COPY(sr); COPY(pc);
3180#undef COPY
3181
d8714436 3182 for (i=0; i<16; i++) {
3183 err |= __put_user(regs->fregs[i], &sc->sc_fpregs[i]);
3184 }
3185 err |= __put_user(regs->fpscr, &sc->sc_fpscr);
3186 err |= __put_user(regs->fpul, &sc->sc_fpul);
c3b5bc8a
TS		 3187
3188 /* non-iBCS2 extensions.. */
3189 err |= __put_user(mask, &sc->oldmask);
3190
3191 return err;
3192}
3193
05390248 3194static int restore_sigcontext(CPUSH4State *regs, struct target_sigcontext *sc,
d8714436 3195 target_ulong *r0_p)
c3b5bc8a
TS		 3196{
3197 unsigned int err = 0;
d8714436 3198 int i;
c3b5bc8a
TS		 3199
3200#define COPY(x) err |= __get_user(regs->x, &sc->sc_##x)
3201 COPY(gregs[1]);
3202 COPY(gregs[2]); COPY(gregs[3]);
3203 COPY(gregs[4]); COPY(gregs[5]);
3204 COPY(gregs[6]); COPY(gregs[7]);
3205 COPY(gregs[8]); COPY(gregs[9]);
3206 COPY(gregs[10]); COPY(gregs[11]);
3207 COPY(gregs[12]); COPY(gregs[13]);
3208 COPY(gregs[14]); COPY(gregs[15]);
3209 COPY(gbr); COPY(mach);
3210 COPY(macl); COPY(pr);
3211 COPY(sr); COPY(pc);
3212#undef COPY
3213
d8714436 3214 for (i=0; i<16; i++) {
3215 err |= __get_user(regs->fregs[i], &sc->sc_fpregs[i]);
3216 }
3217 err |= __get_user(regs->fpscr, &sc->sc_fpscr);
3218 err |= __get_user(regs->fpul, &sc->sc_fpul);
c3b5bc8a
TS		 3219
3220 regs->tra = -1; /* disable syscall checks */
d8714436 3221 err |= __get_user(*r0_p, &sc->sc_gregs[0]);
c3b5bc8a
TS		 3222 return err;
3223}
3224
624f7979 3225static void setup_frame(int sig, struct target_sigaction *ka,
05390248 3226 target_sigset_t *set, CPUSH4State *regs)
c3b5bc8a
TS		 3227{
3228 struct target_sigframe *frame;
3229 abi_ulong frame_addr;
3230 int i;
3231 int err = 0;
3232 int signal;
3233
3234 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
3235 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3236 goto give_sigsegv;
3237
3238 signal = current_exec_domain_sig(sig);
3239
3240 err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
3241
3242 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
3243 err |= __put_user(set->sig[i + 1], &frame->extramask[i]);
3244 }
3245
3246 /* Set up to return from userspace. If provided, use a stub
3247 already in userspace. */
624f7979
PB		 3248 if (ka->sa_flags & TARGET_SA_RESTORER) {
3249 regs->pr = (unsigned long) ka->sa_restorer;
c3b5bc8a
TS		 3250 } else {
3251 /* Generate return code (system call to sigreturn) */
3252 err |= __put_user(MOVW(2), &frame->retcode[0]);
3253 err |= __put_user(TRAP_NOARG, &frame->retcode[1]);
3254 err |= __put_user((TARGET_NR_sigreturn), &frame->retcode[2]);
3255 regs->pr = (unsigned long) frame->retcode;
3256 }
3257
3258 if (err)
3259 goto give_sigsegv;
3260
3261 /* Set up registers for signal handler */
cb9c6268 3262 regs->gregs[15] = frame_addr;
c3b5bc8a
TS		 3263 regs->gregs[4] = signal; /* Arg for signal handler */
3264 regs->gregs[5] = 0;
cb9c6268 3265 regs->gregs[6] = frame_addr += offsetof(typeof(*frame), sc);
624f7979 3266 regs->pc = (unsigned long) ka->_sa_handler;
c3b5bc8a
TS		 3267
3268 unlock_user_struct(frame, frame_addr, 1);
3269 return;
3270
3271give_sigsegv:
3272 unlock_user_struct(frame, frame_addr, 1);
66393fb9 3273 force_sig(TARGET_SIGSEGV);
c3b5bc8a
TS		 3274}
3275
624f7979 3276static void setup_rt_frame(int sig, struct target_sigaction *ka,
c227f099 3277 target_siginfo_t *info,
05390248 3278 target_sigset_t *set, CPUSH4State *regs)
c3b5bc8a
TS		 3279{
3280 struct target_rt_sigframe *frame;
3281 abi_ulong frame_addr;
3282 int i;
3283 int err = 0;
3284 int signal;
3285
3286 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
3287 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3288 goto give_sigsegv;
3289
3290 signal = current_exec_domain_sig(sig);
3291
3292 err |= copy_siginfo_to_user(&frame->info, info);
3293
3294 /* Create the ucontext. */
60e99246
AJ		 3295 err |= __put_user(0, &frame->uc.tuc_flags);
3296 err |= __put_user(0, (unsigned long *)&frame->uc.tuc_link);
526ccb7a 3297 err |= __put_user((unsigned long)target_sigaltstack_used.ss_sp,
60e99246 3298 &frame->uc.tuc_stack.ss_sp);
c3b5bc8a 3299 err |= __put_user(sas_ss_flags(regs->gregs[15]),
60e99246 3300 &frame->uc.tuc_stack.ss_flags);
c3b5bc8a 3301 err |= __put_user(target_sigaltstack_used.ss_size,
60e99246
AJ		 3302 &frame->uc.tuc_stack.ss_size);
3303 err |= setup_sigcontext(&frame->uc.tuc_mcontext,
c3b5bc8a
TS		 3304 regs, set->sig[0]);
3305 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
60e99246 3306 err |= __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
c3b5bc8a
TS		 3307 }
3308
3309 /* Set up to return from userspace. If provided, use a stub
3310 already in userspace. */
624f7979
PB		 3311 if (ka->sa_flags & TARGET_SA_RESTORER) {
3312 regs->pr = (unsigned long) ka->sa_restorer;
c3b5bc8a
TS		 3313 } else {
3314 /* Generate return code (system call to sigreturn) */
3315 err |= __put_user(MOVW(2), &frame->retcode[0]);
3316 err |= __put_user(TRAP_NOARG, &frame->retcode[1]);
3317 err |= __put_user((TARGET_NR_rt_sigreturn), &frame->retcode[2]);
3318 regs->pr = (unsigned long) frame->retcode;
3319 }
3320
3321 if (err)
3322 goto give_sigsegv;
3323
3324 /* Set up registers for signal handler */
cb9c6268 3325 regs->gregs[15] = frame_addr;
c3b5bc8a 3326 regs->gregs[4] = signal; /* Arg for signal handler */
cb9c6268
EI		 3327 regs->gregs[5] = frame_addr + offsetof(typeof(*frame), info);
3328 regs->gregs[6] = frame_addr + offsetof(typeof(*frame), uc);
624f7979 3329 regs->pc = (unsigned long) ka->_sa_handler;
c3b5bc8a
TS		 3330
3331 unlock_user_struct(frame, frame_addr, 1);
3332 return;
3333
3334give_sigsegv:
3335 unlock_user_struct(frame, frame_addr, 1);
66393fb9 3336 force_sig(TARGET_SIGSEGV);
c3b5bc8a
TS		 3337}
3338
05390248 3339long do_sigreturn(CPUSH4State *regs)
c3b5bc8a
TS		 3340{
3341 struct target_sigframe *frame;
3342 abi_ulong frame_addr;
3343 sigset_t blocked;
c227f099 3344 target_sigset_t target_set;
d8714436 3345 target_ulong r0;
c3b5bc8a
TS		 3346 int i;
3347 int err = 0;
3348
3349#if defined(DEBUG_SIGNAL)
3350 fprintf(stderr, "do_sigreturn\n");
3351#endif
3352 frame_addr = regs->gregs[15];
3353 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
3354 goto badframe;
3355
3356 err |= __get_user(target_set.sig[0], &frame->sc.oldmask);
3357 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3358 err |= (__get_user(target_set.sig[i], &frame->extramask[i - 1]));
3359 }
3360
3361 if (err)
3362 goto badframe;
3363
3364 target_to_host_sigset_internal(&blocked, &target_set);
3365 sigprocmask(SIG_SETMASK, &blocked, NULL);
3366
d8714436 3367 if (restore_sigcontext(regs, &frame->sc, &r0))
c3b5bc8a
TS		 3368 goto badframe;
3369
3370 unlock_user_struct(frame, frame_addr, 0);
d8714436 3371 return r0;
c3b5bc8a
TS		 3372
3373badframe:
3374 unlock_user_struct(frame, frame_addr, 0);
3375 force_sig(TARGET_SIGSEGV);
3376 return 0;
3377}
3378
05390248 3379long do_rt_sigreturn(CPUSH4State *regs)
c3b5bc8a
TS		 3380{
3381 struct target_rt_sigframe *frame;
3382 abi_ulong frame_addr;
3383 sigset_t blocked;
d8714436 3384 target_ulong r0;
c3b5bc8a
TS		 3385
3386#if defined(DEBUG_SIGNAL)
3387 fprintf(stderr, "do_rt_sigreturn\n");
3388#endif
3389 frame_addr = regs->gregs[15];
3390 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
3391 goto badframe;
3392
60e99246 3393 target_to_host_sigset(&blocked, &frame->uc.tuc_sigmask);
c3b5bc8a
TS		 3394 sigprocmask(SIG_SETMASK, &blocked, NULL);
3395
60e99246 3396 if (restore_sigcontext(regs, &frame->uc.tuc_mcontext, &r0))
c3b5bc8a
TS		 3397 goto badframe;
3398
3399 if (do_sigaltstack(frame_addr +
60e99246 3400 offsetof(struct target_rt_sigframe, uc.tuc_stack),
c3b5bc8a
TS		 3401 0, get_sp_from_cpustate(regs)) == -EFAULT)
3402 goto badframe;
3403
3404 unlock_user_struct(frame, frame_addr, 0);
d8714436 3405 return r0;
c3b5bc8a
TS		 3406
3407badframe:
3408 unlock_user_struct(frame, frame_addr, 0);
3409 force_sig(TARGET_SIGSEGV);
3410 return 0;
3411}
b779e29e
EI		 3412#elif defined(TARGET_MICROBLAZE)
3413
3414struct target_sigcontext {
3415 struct target_pt_regs regs; /* needs to be first */
3416 uint32_t oldmask;
3417};
3418
b2178704
EI		 3419struct target_stack_t {
3420 abi_ulong ss_sp;
3421 int ss_flags;
3422 unsigned int ss_size;
3423};
3424
3425struct target_ucontext {
f711df67
RH		 3426 abi_ulong tuc_flags;
3427 abi_ulong tuc_link;
3428 struct target_stack_t tuc_stack;
3429 struct target_sigcontext tuc_mcontext;
3430 uint32_t tuc_extramask[TARGET_NSIG_WORDS - 1];
b2178704
EI		 3431};
3432
b779e29e
EI		 3433/* Signal frames. */
3434struct target_signal_frame {
b2178704 3435 struct target_ucontext uc;
b779e29e
EI		 3436 uint32_t extramask[TARGET_NSIG_WORDS - 1];
3437 uint32_t tramp[2];
3438};
3439
3440struct rt_signal_frame {
02d2bd5d 3441 siginfo_t info;
b779e29e
EI		 3442 struct ucontext uc;
3443 uint32_t tramp[2];
3444};
3445
05390248 3446static void setup_sigcontext(struct target_sigcontext *sc, CPUMBState *env)
b779e29e
EI		 3447{
3448 __put_user(env->regs[0], &sc->regs.r0);
3449 __put_user(env->regs[1], &sc->regs.r1);
3450 __put_user(env->regs[2], &sc->regs.r2);
3451 __put_user(env->regs[3], &sc->regs.r3);
3452 __put_user(env->regs[4], &sc->regs.r4);
3453 __put_user(env->regs[5], &sc->regs.r5);
3454 __put_user(env->regs[6], &sc->regs.r6);
3455 __put_user(env->regs[7], &sc->regs.r7);
3456 __put_user(env->regs[8], &sc->regs.r8);
3457 __put_user(env->regs[9], &sc->regs.r9);
3458 __put_user(env->regs[10], &sc->regs.r10);
3459 __put_user(env->regs[11], &sc->regs.r11);
3460 __put_user(env->regs[12], &sc->regs.r12);
3461 __put_user(env->regs[13], &sc->regs.r13);
3462 __put_user(env->regs[14], &sc->regs.r14);
3463 __put_user(env->regs[15], &sc->regs.r15);
3464 __put_user(env->regs[16], &sc->regs.r16);
3465 __put_user(env->regs[17], &sc->regs.r17);
3466 __put_user(env->regs[18], &sc->regs.r18);
3467 __put_user(env->regs[19], &sc->regs.r19);
3468 __put_user(env->regs[20], &sc->regs.r20);
3469 __put_user(env->regs[21], &sc->regs.r21);
3470 __put_user(env->regs[22], &sc->regs.r22);
3471 __put_user(env->regs[23], &sc->regs.r23);
3472 __put_user(env->regs[24], &sc->regs.r24);
3473 __put_user(env->regs[25], &sc->regs.r25);
3474 __put_user(env->regs[26], &sc->regs.r26);
3475 __put_user(env->regs[27], &sc->regs.r27);
3476 __put_user(env->regs[28], &sc->regs.r28);
3477 __put_user(env->regs[29], &sc->regs.r29);
3478 __put_user(env->regs[30], &sc->regs.r30);
3479 __put_user(env->regs[31], &sc->regs.r31);
3480 __put_user(env->sregs[SR_PC], &sc->regs.pc);
3481}
3482
05390248 3483static void restore_sigcontext(struct target_sigcontext *sc, CPUMBState *env)
b779e29e
EI		 3484{
3485 __get_user(env->regs[0], &sc->regs.r0);
3486 __get_user(env->regs[1], &sc->regs.r1);
3487 __get_user(env->regs[2], &sc->regs.r2);
3488 __get_user(env->regs[3], &sc->regs.r3);
3489 __get_user(env->regs[4], &sc->regs.r4);
3490 __get_user(env->regs[5], &sc->regs.r5);
3491 __get_user(env->regs[6], &sc->regs.r6);
3492 __get_user(env->regs[7], &sc->regs.r7);
3493 __get_user(env->regs[8], &sc->regs.r8);
3494 __get_user(env->regs[9], &sc->regs.r9);
3495 __get_user(env->regs[10], &sc->regs.r10);
3496 __get_user(env->regs[11], &sc->regs.r11);
3497 __get_user(env->regs[12], &sc->regs.r12);
3498 __get_user(env->regs[13], &sc->regs.r13);
3499 __get_user(env->regs[14], &sc->regs.r14);
3500 __get_user(env->regs[15], &sc->regs.r15);
3501 __get_user(env->regs[16], &sc->regs.r16);
3502 __get_user(env->regs[17], &sc->regs.r17);
3503 __get_user(env->regs[18], &sc->regs.r18);
3504 __get_user(env->regs[19], &sc->regs.r19);
3505 __get_user(env->regs[20], &sc->regs.r20);
3506 __get_user(env->regs[21], &sc->regs.r21);
3507 __get_user(env->regs[22], &sc->regs.r22);
3508 __get_user(env->regs[23], &sc->regs.r23);
3509 __get_user(env->regs[24], &sc->regs.r24);
3510 __get_user(env->regs[25], &sc->regs.r25);
3511 __get_user(env->regs[26], &sc->regs.r26);
3512 __get_user(env->regs[27], &sc->regs.r27);
3513 __get_user(env->regs[28], &sc->regs.r28);
3514 __get_user(env->regs[29], &sc->regs.r29);
3515 __get_user(env->regs[30], &sc->regs.r30);
3516 __get_user(env->regs[31], &sc->regs.r31);
3517 __get_user(env->sregs[SR_PC], &sc->regs.pc);
3518}
3519
3520static abi_ulong get_sigframe(struct target_sigaction *ka,
05390248 3521 CPUMBState *env, int frame_size)
b779e29e
EI		 3522{
3523 abi_ulong sp = env->regs[1];
3524
3525 if ((ka->sa_flags & SA_ONSTACK) != 0 && !on_sig_stack(sp))
3526 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
3527
3528 return ((sp - frame_size) & -8UL);
3529}
3530
3531static void setup_frame(int sig, struct target_sigaction *ka,
05390248 3532 target_sigset_t *set, CPUMBState *env)
b779e29e
EI		 3533{
3534 struct target_signal_frame *frame;
3535 abi_ulong frame_addr;
3536 int err = 0;
3537 int i;
3538
3539 frame_addr = get_sigframe(ka, env, sizeof *frame);
3540 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3541 goto badframe;
3542
3543 /* Save the mask. */
f711df67 3544 err |= __put_user(set->sig[0], &frame->uc.tuc_mcontext.oldmask);
b779e29e
EI		 3545 if (err)
3546 goto badframe;
3547
3548 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3549 if (__put_user(set->sig[i], &frame->extramask[i - 1]))
3550 goto badframe;
3551 }
3552
f711df67 3553 setup_sigcontext(&frame->uc.tuc_mcontext, env);
b779e29e
EI		 3554
3555 /* Set up to return from userspace. If provided, use a stub
3556 already in userspace. */
3557 /* minus 8 is offset to cater for "rtsd r15,8" offset */
3558 if (ka->sa_flags & TARGET_SA_RESTORER) {
3559 env->regs[15] = ((unsigned long)ka->sa_restorer)-8;
3560 } else {
3561 uint32_t t;
3562 /* Note, these encodings are _big endian_! */
3563 /* addi r12, r0, __NR_sigreturn */
3564 t = 0x31800000UL | TARGET_NR_sigreturn;
3565 err |= __put_user(t, frame->tramp + 0);
3566 /* brki r14, 0x8 */
3567 t = 0xb9cc0008UL;
3568 err |= __put_user(t, frame->tramp + 1);
3569
3570 /* Return from sighandler will jump to the tramp.
3571 Negative 8 offset because return is rtsd r15, 8 */
3572 env->regs[15] = ((unsigned long)frame->tramp) - 8;
3573 }
3574
3575 if (err)
3576 goto badframe;
3577
3578 /* Set up registers for signal handler */
cb9c6268 3579 env->regs[1] = frame_addr;
b779e29e
EI		 3580 /* Signal handler args: */
3581 env->regs[5] = sig; /* Arg 0: signum */
187b4e08 3582 env->regs[6] = 0;
cb9c6268
EI		 3583 /* arg 1: sigcontext */
3584 env->regs[7] = frame_addr += offsetof(typeof(*frame), uc);
b779e29e
EI		 3585
3586 /* Offset of 4 to handle microblaze rtid r14, 0 */
3587 env->sregs[SR_PC] = (unsigned long)ka->_sa_handler;
3588
3589 unlock_user_struct(frame, frame_addr, 1);
3590 return;
3591 badframe:
3592 unlock_user_struct(frame, frame_addr, 1);
3593 force_sig(TARGET_SIGSEGV);
3594}
3595
3596static void setup_rt_frame(int sig, struct target_sigaction *ka,
c227f099 3597 target_siginfo_t *info,
05390248 3598 target_sigset_t *set, CPUMBState *env)
b779e29e
EI		 3599{
3600 fprintf(stderr, "Microblaze setup_rt_frame: not implemented\n");
3601}
3602
05390248 3603long do_sigreturn(CPUMBState *env)
b779e29e
EI		 3604{
3605 struct target_signal_frame *frame;
3606 abi_ulong frame_addr;
c227f099 3607 target_sigset_t target_set;
b779e29e
EI		 3608 sigset_t set;
3609 int i;
3610
3611 frame_addr = env->regs[R_SP];
3612 /* Make sure the guest isn't playing games. */
3613 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
3614 goto badframe;
3615
3616 /* Restore blocked signals */
f711df67 3617 if (__get_user(target_set.sig[0], &frame->uc.tuc_mcontext.oldmask))
b779e29e
EI		 3618 goto badframe;
3619 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3620 if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
3621 goto badframe;
3622 }
3623 target_to_host_sigset_internal(&set, &target_set);
3624 sigprocmask(SIG_SETMASK, &set, NULL);
3625
f711df67 3626 restore_sigcontext(&frame->uc.tuc_mcontext, env);
b779e29e
EI		 3627 /* We got here through a sigreturn syscall, our path back is via an
3628 rtb insn so setup r14 for that. */
3629 env->regs[14] = env->sregs[SR_PC];
3630
3631 unlock_user_struct(frame, frame_addr, 0);
3632 return env->regs[10];
3633 badframe:
3634 unlock_user_struct(frame, frame_addr, 0);
3635 force_sig(TARGET_SIGSEGV);
3636}
3637
05390248 3638long do_rt_sigreturn(CPUMBState *env)
b779e29e
EI		 3639{
3640 fprintf(stderr, "Microblaze do_rt_sigreturn: not implemented\n");
3641 return -TARGET_ENOSYS;
3642}
3643
b6d3abda
EI		 3644#elif defined(TARGET_CRIS)
3645
3646struct target_sigcontext {
3647 struct target_pt_regs regs; /* needs to be first */
3648 uint32_t oldmask;
3649 uint32_t usp; /* usp before stacking this gunk on it */
3650};
3651
3652/* Signal frames. */
3653struct target_signal_frame {
3654 struct target_sigcontext sc;
3655 uint32_t extramask[TARGET_NSIG_WORDS - 1];
3656 uint8_t retcode[8]; /* Trampoline code. */
3657};
3658
3659struct rt_signal_frame {
02d2bd5d 3660 siginfo_t *pinfo;
b6d3abda 3661 void *puc;
02d2bd5d 3662 siginfo_t info;
b6d3abda
EI		 3663 struct ucontext uc;
3664 uint8_t retcode[8]; /* Trampoline code. */
3665};
3666
05390248 3667static void setup_sigcontext(struct target_sigcontext *sc, CPUCRISState *env)
b6d3abda 3668{
9664d928
EI		 3669 __put_user(env->regs[0], &sc->regs.r0);
3670 __put_user(env->regs[1], &sc->regs.r1);
3671 __put_user(env->regs[2], &sc->regs.r2);
3672 __put_user(env->regs[3], &sc->regs.r3);
3673 __put_user(env->regs[4], &sc->regs.r4);
3674 __put_user(env->regs[5], &sc->regs.r5);
3675 __put_user(env->regs[6], &sc->regs.r6);
3676 __put_user(env->regs[7], &sc->regs.r7);
3677 __put_user(env->regs[8], &sc->regs.r8);
3678 __put_user(env->regs[9], &sc->regs.r9);
3679 __put_user(env->regs[10], &sc->regs.r10);
3680 __put_user(env->regs[11], &sc->regs.r11);
3681 __put_user(env->regs[12], &sc->regs.r12);
3682 __put_user(env->regs[13], &sc->regs.r13);
3683 __put_user(env->regs[14], &sc->usp);
3684 __put_user(env->regs[15], &sc->regs.acr);
3685 __put_user(env->pregs[PR_MOF], &sc->regs.mof);
3686 __put_user(env->pregs[PR_SRP], &sc->regs.srp);
3687 __put_user(env->pc, &sc->regs.erp);
b6d3abda 3688}
9664d928 3689
05390248 3690static void restore_sigcontext(struct target_sigcontext *sc, CPUCRISState *env)
b6d3abda 3691{
9664d928
EI		 3692 __get_user(env->regs[0], &sc->regs.r0);
3693 __get_user(env->regs[1], &sc->regs.r1);
3694 __get_user(env->regs[2], &sc->regs.r2);
3695 __get_user(env->regs[3], &sc->regs.r3);
3696 __get_user(env->regs[4], &sc->regs.r4);
3697 __get_user(env->regs[5], &sc->regs.r5);
3698 __get_user(env->regs[6], &sc->regs.r6);
3699 __get_user(env->regs[7], &sc->regs.r7);
3700 __get_user(env->regs[8], &sc->regs.r8);
3701 __get_user(env->regs[9], &sc->regs.r9);
3702 __get_user(env->regs[10], &sc->regs.r10);
3703 __get_user(env->regs[11], &sc->regs.r11);
3704 __get_user(env->regs[12], &sc->regs.r12);
3705 __get_user(env->regs[13], &sc->regs.r13);
3706 __get_user(env->regs[14], &sc->usp);
3707 __get_user(env->regs[15], &sc->regs.acr);
3708 __get_user(env->pregs[PR_MOF], &sc->regs.mof);
3709 __get_user(env->pregs[PR_SRP], &sc->regs.srp);
3710 __get_user(env->pc, &sc->regs.erp);
3711}
3712
05390248 3713static abi_ulong get_sigframe(CPUCRISState *env, int framesize)
9664d928
EI		 3714{
3715 abi_ulong sp;
b6d3abda 3716 /* Align the stack downwards to 4. */
9664d928
EI		 3717 sp = (env->regs[R_SP] & ~3);
3718 return sp - framesize;
b6d3abda
EI		 3719}
3720
624f7979 3721static void setup_frame(int sig, struct target_sigaction *ka,
05390248 3722 target_sigset_t *set, CPUCRISState *env)
b6d3abda
EI		 3723{
3724 struct target_signal_frame *frame;
9664d928 3725 abi_ulong frame_addr;
b6d3abda
EI		 3726 int err = 0;
3727 int i;
b6d3abda 3728
9664d928
EI		 3729 frame_addr = get_sigframe(env, sizeof *frame);
3730 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
b6d3abda
EI		 3731 goto badframe;
3732
3733 /*
3734 * The CRIS signal return trampoline. A real linux/CRIS kernel doesn't
3735 * use this trampoline anymore but it sets it up for GDB.
3736 * In QEMU, using the trampoline simplifies things a bit so we use it.
3737 *
3738 * This is movu.w __NR_sigreturn, r9; break 13;
3739 */
3740 err |= __put_user(0x9c5f, frame->retcode+0);
3741 err |= __put_user(TARGET_NR_sigreturn,
3742 frame->retcode+2);
3743 err |= __put_user(0xe93d, frame->retcode+4);
3744
3745 /* Save the mask. */
3746 err |= __put_user(set->sig[0], &frame->sc.oldmask);
3747 if (err)
3748 goto badframe;
3749
3750 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3751 if (__put_user(set->sig[i], &frame->extramask[i - 1]))
3752 goto badframe;
3753 }
3754
3755 setup_sigcontext(&frame->sc, env);
3756
3757 /* Move the stack and setup the arguments for the handler. */
cb9c6268 3758 env->regs[R_SP] = frame_addr;
b6d3abda 3759 env->regs[10] = sig;
624f7979 3760 env->pc = (unsigned long) ka->_sa_handler;
b6d3abda 3761 /* Link SRP so the guest returns through the trampoline. */
cb9c6268 3762 env->pregs[PR_SRP] = frame_addr + offsetof(typeof(*frame), retcode);
b6d3abda 3763
9664d928 3764 unlock_user_struct(frame, frame_addr, 1);
b6d3abda
EI		 3765 return;
3766 badframe:
9664d928 3767 unlock_user_struct(frame, frame_addr, 1);
b6d3abda
EI		 3768 force_sig(TARGET_SIGSEGV);
3769}
3770
624f7979 3771static void setup_rt_frame(int sig, struct target_sigaction *ka,
c227f099 3772 target_siginfo_t *info,
05390248 3773 target_sigset_t *set, CPUCRISState *env)
b6d3abda
EI		 3774{
3775 fprintf(stderr, "CRIS setup_rt_frame: not implemented\n");
3776}
3777
05390248 3778long do_sigreturn(CPUCRISState *env)
b6d3abda
EI		 3779{
3780 struct target_signal_frame *frame;
9664d928 3781 abi_ulong frame_addr;
c227f099 3782 target_sigset_t target_set;
b6d3abda
EI		 3783 sigset_t set;
3784 int i;
3785
9664d928 3786 frame_addr = env->regs[R_SP];
b6d3abda 3787 /* Make sure the guest isn't playing games. */
9664d928 3788 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
b6d3abda
EI		 3789 goto badframe;
3790
3791 /* Restore blocked signals */
3792 if (__get_user(target_set.sig[0], &frame->sc.oldmask))
3793 goto badframe;
3794 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3795 if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
3796 goto badframe;
3797 }
3798 target_to_host_sigset_internal(&set, &target_set);
3799 sigprocmask(SIG_SETMASK, &set, NULL);
3800
3801 restore_sigcontext(&frame->sc, env);
9664d928 3802 unlock_user_struct(frame, frame_addr, 0);
b6d3abda
EI		 3803 return env->regs[10];
3804 badframe:
9664d928 3805 unlock_user_struct(frame, frame_addr, 0);
b6d3abda
EI		 3806 force_sig(TARGET_SIGSEGV);
3807}
3808
05390248 3809long do_rt_sigreturn(CPUCRISState *env)
b6d3abda
EI		 3810{
3811 fprintf(stderr, "CRIS do_rt_sigreturn: not implemented\n");
3812 return -TARGET_ENOSYS;
3813}
c3b5bc8a 3814
d962783e
JL		 3815#elif defined(TARGET_OPENRISC)
3816
3817struct target_sigcontext {
3818 struct target_pt_regs regs;
3819 abi_ulong oldmask;
3820 abi_ulong usp;
3821};
3822
3823struct target_ucontext {
3824 abi_ulong tuc_flags;
3825 abi_ulong tuc_link;
3826 target_stack_t tuc_stack;
3827 struct target_sigcontext tuc_mcontext;
3828 target_sigset_t tuc_sigmask; /* mask last for extensibility */
3829};
3830
3831struct target_rt_sigframe {
3832 abi_ulong pinfo;
3833 uint64_t puc;
3834 struct target_siginfo info;
3835 struct target_sigcontext sc;
3836 struct target_ucontext uc;
3837 unsigned char retcode[16]; /* trampoline code */
3838};
3839
3840/* This is the asm-generic/ucontext.h version */
3841#if 0
3842static int restore_sigcontext(CPUOpenRISCState *regs,
3843 struct target_sigcontext *sc)
3844{
3845 unsigned int err = 0;
3846 unsigned long old_usp;
3847
3848 /* Alwys make any pending restarted system call return -EINTR */
3849 current_thread_info()->restart_block.fn = do_no_restart_syscall;
3850
3851 /* restore the regs from &sc->regs (same as sc, since regs is first)
3852 * (sc is already checked for VERIFY_READ since the sigframe was
3853 * checked in sys_sigreturn previously)
3854 */
3855
3856 if (copy_from_user(regs, &sc, sizeof(struct target_pt_regs))) {
3857 goto badframe;
3858 }
3859
3860 /* make sure the U-flag is set so user-mode cannot fool us */
3861
3862 regs->sr &= ~SR_SM;
3863
3864 /* restore the old USP as it was before we stacked the sc etc.
3865 * (we cannot just pop the sigcontext since we aligned the sp and
3866 * stuff after pushing it)
3867 */
3868
3869 err |= __get_user(old_usp, &sc->usp);
3870 phx_signal("old_usp 0x%lx", old_usp);
3871
3872 __PHX__ REALLY /* ??? */
3873 wrusp(old_usp);
3874 regs->gpr[1] = old_usp;
3875
3876 /* TODO: the other ports use regs->orig_XX to disable syscall checks
3877 * after this completes, but we don't use that mechanism. maybe we can
3878 * use it now ?
3879 */
3880
3881 return err;
3882
3883badframe:
3884 return 1;
3885}
3886#endif
3887
3888/* Set up a signal frame. */
3889
3890static int setup_sigcontext(struct target_sigcontext *sc,
3891 CPUOpenRISCState *regs,
3892 unsigned long mask)
3893{
3894 int err = 0;
3895 unsigned long usp = regs->gpr[1];
3896
3897 /* copy the regs. they are first in sc so we can use sc directly */
3898
3899 /*err |= copy_to_user(&sc, regs, sizeof(struct target_pt_regs));*/
3900
3901 /* Set the frametype to CRIS_FRAME_NORMAL for the execution of
3902 the signal handler. The frametype will be restored to its previous
3903 value in restore_sigcontext. */
3904 /*regs->frametype = CRIS_FRAME_NORMAL;*/
3905
3906 /* then some other stuff */
3907 err |= __put_user(mask, &sc->oldmask);
3908 err |= __put_user(usp, &sc->usp); return err;
3909}
3910
3911static inline unsigned long align_sigframe(unsigned long sp)
3912{
3913 unsigned long i;
3914 i = sp & ~3UL;
3915 return i;
3916}
3917
3918static inline abi_ulong get_sigframe(struct target_sigaction *ka,
3919 CPUOpenRISCState *regs,
3920 size_t frame_size)
3921{
3922 unsigned long sp = regs->gpr[1];
3923 int onsigstack = on_sig_stack(sp);
3924
3925 /* redzone */
3926 /* This is the X/Open sanctioned signal stack switching. */
3927 if ((ka->sa_flags & SA_ONSTACK) != 0 && !onsigstack) {
3928 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
3929 }
3930
3931 sp = align_sigframe(sp - frame_size);
3932
3933 /*
3934 * If we are on the alternate signal stack and would overflow it, don't.
3935 * Return an always-bogus address instead so we will die with SIGSEGV.
3936 */
3937
3938 if (onsigstack && !likely(on_sig_stack(sp))) {
3939 return -1L;
3940 }
3941
3942 return sp;
3943}
3944
3945static void setup_frame(int sig, struct target_sigaction *ka,
3946 target_sigset_t *set, CPUOpenRISCState *env)
3947{
3948 qemu_log("Not implement.\n");
3949}
3950
3951static void setup_rt_frame(int sig, struct target_sigaction *ka,
3952 target_siginfo_t *info,
3953 target_sigset_t *set, CPUOpenRISCState *env)
3954{
3955 int err = 0;
3956 abi_ulong frame_addr;
3957 unsigned long return_ip;
3958 struct target_rt_sigframe *frame;
3959 abi_ulong info_addr, uc_addr;
3960
3961 frame_addr = get_sigframe(ka, env, sizeof *frame);
3962
3963 frame_addr = get_sigframe(ka, env, sizeof(*frame));
3964 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
3965 goto give_sigsegv;
3966 }
3967
3968 info_addr = frame_addr + offsetof(struct target_rt_sigframe, info);
3969 err |= __put_user(info_addr, &frame->pinfo);
3970 uc_addr = frame_addr + offsetof(struct target_rt_sigframe, uc);
3971 err |= __put_user(uc_addr, &frame->puc);
3972
3973 if (ka->sa_flags & SA_SIGINFO) {
3974 err |= copy_siginfo_to_user(&frame->info, info);
3975 }
3976 if (err) {
3977 goto give_sigsegv;
3978 }
3979
3980 /*err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext));*/
3981 err |= __put_user(0, &frame->uc.tuc_flags);
3982 err |= __put_user(0, &frame->uc.tuc_link);
3983 err |= __put_user(target_sigaltstack_used.ss_sp,
3984 &frame->uc.tuc_stack.ss_sp);
3985 err |= __put_user(sas_ss_flags(env->gpr[1]), &frame->uc.tuc_stack.ss_flags);
3986 err |= __put_user(target_sigaltstack_used.ss_size,
3987 &frame->uc.tuc_stack.ss_size);
3988 err |= setup_sigcontext(&frame->sc, env, set->sig[0]);
3989
3990 /*err |= copy_to_user(frame->uc.tuc_sigmask, set, sizeof(*set));*/
3991
3992 if (err) {
3993 goto give_sigsegv;
3994 }
3995
3996 /* trampoline - the desired return ip is the retcode itself */
3997 return_ip = (unsigned long)&frame->retcode;
3998 /* This is l.ori r11,r0,__NR_sigreturn, l.sys 1 */
3999 err |= __put_user(0xa960, (short *)(frame->retcode + 0));
4000 err |= __put_user(TARGET_NR_rt_sigreturn, (short *)(frame->retcode + 2));
4001 err |= __put_user(0x20000001, (unsigned long *)(frame->retcode + 4));
4002 err |= __put_user(0x15000000, (unsigned long *)(frame->retcode + 8));
4003
4004 if (err) {
4005 goto give_sigsegv;
4006 }
4007
4008 /* TODO what is the current->exec_domain stuff and invmap ? */
4009
4010 /* Set up registers for signal handler */
4011 env->pc = (unsigned long)ka->_sa_handler; /* what we enter NOW */
4012 env->gpr[9] = (unsigned long)return_ip; /* what we enter LATER */
4013 env->gpr[3] = (unsigned long)sig; /* arg 1: signo */
4014 env->gpr[4] = (unsigned long)&frame->info; /* arg 2: (siginfo_t*) */
4015 env->gpr[5] = (unsigned long)&frame->uc; /* arg 3: ucontext */
4016
4017 /* actually move the usp to reflect the stacked frame */
4018 env->gpr[1] = (unsigned long)frame;
4019
4020 return;
4021
4022give_sigsegv:
4023 unlock_user_struct(frame, frame_addr, 1);
4024 if (sig == TARGET_SIGSEGV) {
4025 ka->_sa_handler = TARGET_SIG_DFL;
4026 }
4027 force_sig(TARGET_SIGSEGV);
4028}
4029
4030long do_sigreturn(CPUOpenRISCState *env)
4031{
4032
4033 qemu_log("do_sigreturn: not implemented\n");
4034 return -TARGET_ENOSYS;
4035}
4036
4037long do_rt_sigreturn(CPUOpenRISCState *env)
4038{
4039 qemu_log("do_rt_sigreturn: not implemented\n");
4040 return -TARGET_ENOSYS;
4041}
4042/* TARGET_OPENRISC */
4043
a4c075f1
UH		 4044#elif defined(TARGET_S390X)
4045
4046#define __NUM_GPRS 16
4047#define __NUM_FPRS 16
4048#define __NUM_ACRS 16
4049
4050#define S390_SYSCALL_SIZE 2
4051#define __SIGNAL_FRAMESIZE 160 /* FIXME: 31-bit mode -> 96 */
4052
4053#define _SIGCONTEXT_NSIG 64
4054#define _SIGCONTEXT_NSIG_BPW 64 /* FIXME: 31-bit mode -> 32 */
4055#define _SIGCONTEXT_NSIG_WORDS (_SIGCONTEXT_NSIG / _SIGCONTEXT_NSIG_BPW)
4056#define _SIGMASK_COPY_SIZE (sizeof(unsigned long)*_SIGCONTEXT_NSIG_WORDS)
4057#define PSW_ADDR_AMODE 0x0000000000000000UL /* 0x80000000UL for 31-bit */
4058#define S390_SYSCALL_OPCODE ((uint16_t)0x0a00)
4059
4060typedef struct {
4061 target_psw_t psw;
4062 target_ulong gprs[__NUM_GPRS];
4063 unsigned int acrs[__NUM_ACRS];
4064} target_s390_regs_common;
4065
4066typedef struct {
4067 unsigned int fpc;
4068 double fprs[__NUM_FPRS];
4069} target_s390_fp_regs;
4070
4071typedef struct {
4072 target_s390_regs_common regs;
4073 target_s390_fp_regs fpregs;
4074} target_sigregs;
4075
4076struct target_sigcontext {
4077 target_ulong oldmask[_SIGCONTEXT_NSIG_WORDS];
4078 target_sigregs *sregs;
4079};
4080
4081typedef struct {
4082 uint8_t callee_used_stack[__SIGNAL_FRAMESIZE];
4083 struct target_sigcontext sc;
4084 target_sigregs sregs;
4085 int signo;
4086 uint8_t retcode[S390_SYSCALL_SIZE];
4087} sigframe;
4088
4089struct target_ucontext {
6fea2ea4
PM		 4090 target_ulong tuc_flags;
4091 struct target_ucontext *tuc_link;
4092 target_stack_t tuc_stack;
4093 target_sigregs tuc_mcontext;
4094 target_sigset_t tuc_sigmask; /* mask last for extensibility */
a4c075f1
UH		 4095};
4096
4097typedef struct {
4098 uint8_t callee_used_stack[__SIGNAL_FRAMESIZE];
4099 uint8_t retcode[S390_SYSCALL_SIZE];
4100 struct target_siginfo info;
4101 struct target_ucontext uc;
4102} rt_sigframe;
4103
4104static inline abi_ulong
05390248 4105get_sigframe(struct target_sigaction *ka, CPUS390XState *env, size_t frame_size)
a4c075f1
UH		 4106{
4107 abi_ulong sp;
4108
4109 /* Default to using normal stack */
4110 sp = env->regs[15];
4111
4112 /* This is the X/Open sanctioned signal stack switching. */
4113 if (ka->sa_flags & TARGET_SA_ONSTACK) {
4114 if (!sas_ss_flags(sp)) {
4115 sp = target_sigaltstack_used.ss_sp +
4116 target_sigaltstack_used.ss_size;
4117 }
4118 }
4119
4120 /* This is the legacy signal stack switching. */
4121 else if (/* FIXME !user_mode(regs) */ 0 &&
4122 !(ka->sa_flags & TARGET_SA_RESTORER) &&
4123 ka->sa_restorer) {
4124 sp = (abi_ulong) ka->sa_restorer;
4125 }
4126
4127 return (sp - frame_size) & -8ul;
4128}
4129
05390248 4130static void save_sigregs(CPUS390XState *env, target_sigregs *sregs)
a4c075f1
UH		 4131{
4132 int i;
4133 //save_access_regs(current->thread.acrs); FIXME
4134
4135 /* Copy a 'clean' PSW mask to the user to avoid leaking
4136 information about whether PER is currently on. */
4137 __put_user(env->psw.mask, &sregs->regs.psw.mask);
4138 __put_user(env->psw.addr, &sregs->regs.psw.addr);
4139 for (i = 0; i < 16; i++) {
4140 __put_user(env->regs[i], &sregs->regs.gprs[i]);
4141 }
4142 for (i = 0; i < 16; i++) {
4143 __put_user(env->aregs[i], &sregs->regs.acrs[i]);
4144 }
4145 /*
4146 * We have to store the fp registers to current->thread.fp_regs
4147 * to merge them with the emulated registers.
4148 */
4149 //save_fp_regs(&current->thread.fp_regs); FIXME
4150 for (i = 0; i < 16; i++) {
4151 __put_user(env->fregs[i].ll, &sregs->fpregs.fprs[i]);
4152 }
4153}
4154
4155static void setup_frame(int sig, struct target_sigaction *ka,
05390248 4156 target_sigset_t *set, CPUS390XState *env)
a4c075f1
UH		 4157{
4158 sigframe *frame;
4159 abi_ulong frame_addr;
4160
4161 frame_addr = get_sigframe(ka, env, sizeof(*frame));
4162 qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__,
4163 (unsigned long long)frame_addr);
4164 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
4165 goto give_sigsegv;
4166 }
4167
4168 qemu_log("%s: 1\n", __FUNCTION__);
4169 if (__put_user(set->sig[0], &frame->sc.oldmask[0])) {
4170 goto give_sigsegv;
4171 }
4172
4173 save_sigregs(env, &frame->sregs);
4174
4175 __put_user((abi_ulong)(unsigned long)&frame->sregs,
4176 (abi_ulong *)&frame->sc.sregs);
4177
4178 /* Set up to return from userspace. If provided, use a stub
4179 already in userspace. */
4180 if (ka->sa_flags & TARGET_SA_RESTORER) {
4181 env->regs[14] = (unsigned long)
4182 ka->sa_restorer | PSW_ADDR_AMODE;
4183 } else {
4184 env->regs[14] = (unsigned long)
4185 frame->retcode | PSW_ADDR_AMODE;
4186 if (__put_user(S390_SYSCALL_OPCODE | TARGET_NR_sigreturn,
4187 (uint16_t *)(frame->retcode)))
4188 goto give_sigsegv;
4189 }
4190
4191 /* Set up backchain. */
4192 if (__put_user(env->regs[15], (abi_ulong *) frame)) {
4193 goto give_sigsegv;
4194 }
4195
4196 /* Set up registers for signal handler */
cb9c6268 4197 env->regs[15] = frame_addr;
a4c075f1
UH		 4198 env->psw.addr = (target_ulong) ka->_sa_handler | PSW_ADDR_AMODE;
4199
4200 env->regs[2] = sig; //map_signal(sig);
cb9c6268 4201 env->regs[3] = frame_addr += offsetof(typeof(*frame), sc);
a4c075f1
UH		 4202
4203 /* We forgot to include these in the sigcontext.
4204 To avoid breaking binary compatibility, they are passed as args. */
4205 env->regs[4] = 0; // FIXME: no clue... current->thread.trap_no;
4206 env->regs[5] = 0; // FIXME: no clue... current->thread.prot_addr;
4207
4208 /* Place signal number on stack to allow backtrace from handler. */
4209 if (__put_user(env->regs[2], (int *) &frame->signo)) {
4210 goto give_sigsegv;
4211 }
4212 unlock_user_struct(frame, frame_addr, 1);
4213 return;
4214
4215give_sigsegv:
4216 qemu_log("%s: give_sigsegv\n", __FUNCTION__);
4217 unlock_user_struct(frame, frame_addr, 1);
4218 force_sig(TARGET_SIGSEGV);
4219}
4220
4221static void setup_rt_frame(int sig, struct target_sigaction *ka,
4222 target_siginfo_t *info,
05390248 4223 target_sigset_t *set, CPUS390XState *env)
a4c075f1
UH		 4224{
4225 int i;
4226 rt_sigframe *frame;
4227 abi_ulong frame_addr;
4228
4229 frame_addr = get_sigframe(ka, env, sizeof *frame);
4230 qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__,
4231 (unsigned long long)frame_addr);
4232 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
4233 goto give_sigsegv;
4234 }
4235
4236 qemu_log("%s: 1\n", __FUNCTION__);
4237 if (copy_siginfo_to_user(&frame->info, info)) {
4238 goto give_sigsegv;
4239 }
4240
4241 /* Create the ucontext. */
6fea2ea4
PM		 4242 __put_user(0, &frame->uc.tuc_flags);
4243 __put_user((abi_ulong)0, (abi_ulong *)&frame->uc.tuc_link);
4244 __put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp);
a4c075f1 4245 __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
6fea2ea4
PM		 4246 &frame->uc.tuc_stack.ss_flags);
4247 __put_user(target_sigaltstack_used.ss_size, &frame->uc.tuc_stack.ss_size);
4248 save_sigregs(env, &frame->uc.tuc_mcontext);
a4c075f1
UH		 4249 for (i = 0; i < TARGET_NSIG_WORDS; i++) {
4250 __put_user((abi_ulong)set->sig[i],
6fea2ea4 4251 (abi_ulong *)&frame->uc.tuc_sigmask.sig[i]);
a4c075f1
UH		 4252 }
4253
4254 /* Set up to return from userspace. If provided, use a stub
4255 already in userspace. */
4256 if (ka->sa_flags & TARGET_SA_RESTORER) {
4257 env->regs[14] = (unsigned long) ka->sa_restorer | PSW_ADDR_AMODE;
4258 } else {
4259 env->regs[14] = (unsigned long) frame->retcode | PSW_ADDR_AMODE;
4260 if (__put_user(S390_SYSCALL_OPCODE | TARGET_NR_rt_sigreturn,
4261 (uint16_t *)(frame->retcode))) {
4262 goto give_sigsegv;
4263 }
4264 }
4265
4266 /* Set up backchain. */
4267 if (__put_user(env->regs[15], (abi_ulong *) frame)) {
4268 goto give_sigsegv;
4269 }
4270
4271 /* Set up registers for signal handler */
cb9c6268 4272 env->regs[15] = frame_addr;
a4c075f1
UH		 4273 env->psw.addr = (target_ulong) ka->_sa_handler | PSW_ADDR_AMODE;
4274
4275 env->regs[2] = sig; //map_signal(sig);
cb9c6268
EI		 4276 env->regs[3] = frame_addr + offsetof(typeof(*frame), info);
4277 env->regs[4] = frame_addr + offsetof(typeof(*frame), uc);
a4c075f1
UH		 4278 return;
4279
4280give_sigsegv:
4281 qemu_log("%s: give_sigsegv\n", __FUNCTION__);
4282 unlock_user_struct(frame, frame_addr, 1);
4283 force_sig(TARGET_SIGSEGV);
4284}
4285
4286static int
05390248 4287restore_sigregs(CPUS390XState *env, target_sigregs *sc)
a4c075f1
UH		 4288{
4289 int err = 0;
4290 int i;
4291
4292 for (i = 0; i < 16; i++) {
4293 err |= __get_user(env->regs[i], &sc->regs.gprs[i]);
4294 }
4295
4296 err |= __get_user(env->psw.mask, &sc->regs.psw.mask);
4297 qemu_log("%s: sc->regs.psw.addr 0x%llx env->psw.addr 0x%llx\n",
4298 __FUNCTION__, (unsigned long long)sc->regs.psw.addr,
4299 (unsigned long long)env->psw.addr);
4300 err |= __get_user(env->psw.addr, &sc->regs.psw.addr);
4301 /* FIXME: 31-bit -> | PSW_ADDR_AMODE */
4302
4303 for (i = 0; i < 16; i++) {
4304 err |= __get_user(env->aregs[i], &sc->regs.acrs[i]);
4305 }
4306 for (i = 0; i < 16; i++) {
4307 err |= __get_user(env->fregs[i].ll, &sc->fpregs.fprs[i]);
4308 }
4309
4310 return err;
4311}
4312
05390248 4313long do_sigreturn(CPUS390XState *env)
a4c075f1
UH		 4314{
4315 sigframe *frame;
4316 abi_ulong frame_addr = env->regs[15];
4317 qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__,
4318 (unsigned long long)frame_addr);
4319 target_sigset_t target_set;
4320 sigset_t set;
4321
4322 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
4323 goto badframe;
4324 }
4325 if (__get_user(target_set.sig[0], &frame->sc.oldmask[0])) {
4326 goto badframe;
4327 }
4328
4329 target_to_host_sigset_internal(&set, &target_set);
4330 sigprocmask(SIG_SETMASK, &set, NULL); /* ~_BLOCKABLE? */
4331
4332 if (restore_sigregs(env, &frame->sregs)) {
4333 goto badframe;
4334 }
4335
4336 unlock_user_struct(frame, frame_addr, 0);
4337 return env->regs[2];
4338
4339badframe:
4340 unlock_user_struct(frame, frame_addr, 0);
4341 force_sig(TARGET_SIGSEGV);
4342 return 0;
4343}
4344
05390248 4345long do_rt_sigreturn(CPUS390XState *env)
a4c075f1
UH		 4346{
4347 rt_sigframe *frame;
4348 abi_ulong frame_addr = env->regs[15];
4349 qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__,
4350 (unsigned long long)frame_addr);
4351 sigset_t set;
4352
4353 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
4354 goto badframe;
4355 }
6fea2ea4 4356 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
a4c075f1
UH		 4357
4358 sigprocmask(SIG_SETMASK, &set, NULL); /* ~_BLOCKABLE? */
4359
6fea2ea4 4360 if (restore_sigregs(env, &frame->uc.tuc_mcontext)) {
a4c075f1
UH		 4361 goto badframe;
4362 }
4363
6fea2ea4 4364 if (do_sigaltstack(frame_addr + offsetof(rt_sigframe, uc.tuc_stack), 0,
a4c075f1
UH		 4365 get_sp_from_cpustate(env)) == -EFAULT) {
4366 goto badframe;
4367 }
4368 unlock_user_struct(frame, frame_addr, 0);
4369 return env->regs[2];
4370
4371badframe:
4372 unlock_user_struct(frame, frame_addr, 0);
4373 force_sig(TARGET_SIGSEGV);
4374 return 0;
4375}
4376
bcd4933a
NF		 4377#elif defined(TARGET_PPC) && !defined(TARGET_PPC64)
4378
4379/* FIXME: Many of the structures are defined for both PPC and PPC64, but
4380 the signal handling is different enough that we haven't implemented
4381 support for PPC64 yet. Hence the restriction above.
4382
4383 There are various #if'd blocks for code for TARGET_PPC64. These
4384 blocks should go away so that we can successfully run 32-bit and
4385 64-bit binaries on a QEMU configured for PPC64. */
4386
4387/* Size of dummy stack frame allocated when calling signal handler.
4388 See arch/powerpc/include/asm/ptrace.h. */
4389#if defined(TARGET_PPC64)
4390#define SIGNAL_FRAMESIZE 128
4391#else
4392#define SIGNAL_FRAMESIZE 64
4393#endif
4394
4395/* See arch/powerpc/include/asm/sigcontext.h. */
4396struct target_sigcontext {
4397 target_ulong _unused[4];
4398 int32_t signal;
4399#if defined(TARGET_PPC64)
4400 int32_t pad0;
4401#endif
4402 target_ulong handler;
4403 target_ulong oldmask;
4404 target_ulong regs; /* struct pt_regs __user * */
4405 /* TODO: PPC64 includes extra bits here. */
4406};
4407
4408/* Indices for target_mcontext.mc_gregs, below.
4409 See arch/powerpc/include/asm/ptrace.h for details. */
4410enum {
4411 TARGET_PT_R0 = 0,
4412 TARGET_PT_R1 = 1,
4413 TARGET_PT_R2 = 2,
4414 TARGET_PT_R3 = 3,
4415 TARGET_PT_R4 = 4,
4416 TARGET_PT_R5 = 5,
4417 TARGET_PT_R6 = 6,
4418 TARGET_PT_R7 = 7,
4419 TARGET_PT_R8 = 8,
4420 TARGET_PT_R9 = 9,
4421 TARGET_PT_R10 = 10,
4422 TARGET_PT_R11 = 11,
4423 TARGET_PT_R12 = 12,
4424 TARGET_PT_R13 = 13,
4425 TARGET_PT_R14 = 14,
4426 TARGET_PT_R15 = 15,
4427 TARGET_PT_R16 = 16,
4428 TARGET_PT_R17 = 17,
4429 TARGET_PT_R18 = 18,
4430 TARGET_PT_R19 = 19,
4431 TARGET_PT_R20 = 20,
4432 TARGET_PT_R21 = 21,
4433 TARGET_PT_R22 = 22,
4434 TARGET_PT_R23 = 23,
4435 TARGET_PT_R24 = 24,
4436 TARGET_PT_R25 = 25,
4437 TARGET_PT_R26 = 26,
4438 TARGET_PT_R27 = 27,
4439 TARGET_PT_R28 = 28,
4440 TARGET_PT_R29 = 29,
4441 TARGET_PT_R30 = 30,
4442 TARGET_PT_R31 = 31,
4443 TARGET_PT_NIP = 32,
4444 TARGET_PT_MSR = 33,
4445 TARGET_PT_ORIG_R3 = 34,
4446 TARGET_PT_CTR = 35,
4447 TARGET_PT_LNK = 36,
4448 TARGET_PT_XER = 37,
4449 TARGET_PT_CCR = 38,
4450 /* Yes, there are two registers with #39. One is 64-bit only. */
4451 TARGET_PT_MQ = 39,
4452 TARGET_PT_SOFTE = 39,
4453 TARGET_PT_TRAP = 40,
4454 TARGET_PT_DAR = 41,
4455 TARGET_PT_DSISR = 42,
4456 TARGET_PT_RESULT = 43,
4457 TARGET_PT_REGS_COUNT = 44
4458};
4459
4460/* See arch/powerpc/include/asm/ucontext.h. Only used for 32-bit PPC;
4461 on 64-bit PPC, sigcontext and mcontext are one and the same. */
4462struct target_mcontext {
4463 target_ulong mc_gregs[48];
4464 /* Includes fpscr. */
4465 uint64_t mc_fregs[33];
4466 target_ulong mc_pad[2];
4467 /* We need to handle Altivec and SPE at the same time, which no
4468 kernel needs to do. Fortunately, the kernel defines this bit to
4469 be Altivec-register-large all the time, rather than trying to
4470 twiddle it based on the specific platform. */
4471 union {
4472 /* SPE vector registers. One extra for SPEFSCR. */
4473 uint32_t spe[33];
4474 /* Altivec vector registers. The packing of VSCR and VRSAVE
4475 varies depending on whether we're PPC64 or not: PPC64 splits
4476 them apart; PPC32 stuffs them together. */
4477#if defined(TARGET_PPC64)
3efa9a67 4478#define QEMU_NVRREG 34
bcd4933a 4479#else
3efa9a67 4480#define QEMU_NVRREG 33
bcd4933a 4481#endif
c227f099 4482 ppc_avr_t altivec[QEMU_NVRREG];
3efa9a67 4483#undef QEMU_NVRREG
bcd4933a
NF		 4484 } mc_vregs __attribute__((__aligned__(16)));
4485};
4486
4487struct target_ucontext {
60e99246
AJ		 4488 target_ulong tuc_flags;
4489 target_ulong tuc_link; /* struct ucontext __user * */
4490 struct target_sigaltstack tuc_stack;
bcd4933a 4491#if !defined(TARGET_PPC64)
60e99246
AJ		 4492 int32_t tuc_pad[7];
4493 target_ulong tuc_regs; /* struct mcontext __user *
bcd4933a
NF		 4494 points to uc_mcontext field */
4495#endif
60e99246 4496 target_sigset_t tuc_sigmask;
bcd4933a 4497#if defined(TARGET_PPC64)
c227f099 4498 target_sigset_t unused[15]; /* Allow for uc_sigmask growth */
60e99246 4499 struct target_sigcontext tuc_mcontext;
bcd4933a 4500#else
60e99246
AJ		 4501 int32_t tuc_maskext[30];
4502 int32_t tuc_pad2[3];
4503 struct target_mcontext tuc_mcontext;
bcd4933a
NF		 4504#endif
4505};
4506
4507/* See arch/powerpc/kernel/signal_32.c. */
4508struct target_sigframe {
4509 struct target_sigcontext sctx;
4510 struct target_mcontext mctx;
4511 int32_t abigap[56];
4512};
4513
4514struct target_rt_sigframe {
4515 struct target_siginfo info;
4516 struct target_ucontext uc;
4517 int32_t abigap[56];
4518};
4519
4520/* We use the mc_pad field for the signal return trampoline. */
4521#define tramp mc_pad
4522
4523/* See arch/powerpc/kernel/signal.c. */
4524static target_ulong get_sigframe(struct target_sigaction *ka,
05390248 4525 CPUPPCState *env,
bcd4933a
NF		 4526 int frame_size)
4527{
4528 target_ulong oldsp, newsp;
4529
4530 oldsp = env->gpr[1];
4531
4532 if ((ka->sa_flags & TARGET_SA_ONSTACK) &&
32a2003a 4533 (sas_ss_flags(oldsp) == 0)) {
bcd4933a
NF		 4534 oldsp = (target_sigaltstack_used.ss_sp
4535 + target_sigaltstack_used.ss_size);
4536 }
4537
4538 newsp = (oldsp - frame_size) & ~0xFUL;
4539
4540 return newsp;
4541}
4542
05390248 4543static int save_user_regs(CPUPPCState *env, struct target_mcontext *frame,
bcd4933a
NF		 4544 int sigret)
4545{
4546 target_ulong msr = env->msr;
4547 int i;
4548 target_ulong ccr = 0;
4549
4550 /* In general, the kernel attempts to be intelligent about what it
4551 needs to save for Altivec/FP/SPE registers. We don't care that
4552 much, so we just go ahead and save everything. */
4553
4554 /* Save general registers. */
4555 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
4556 if (__put_user(env->gpr[i], &frame->mc_gregs[i])) {
4557 return 1;
4558 }
4559 }
4560 if (__put_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP])
4561 || __put_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR])
4562 || __put_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK])
4563 || __put_user(env->xer, &frame->mc_gregs[TARGET_PT_XER]))
4564 return 1;
4565
4566 for (i = 0; i < ARRAY_SIZE(env->crf); i++) {
4567 ccr |= env->crf[i] << (32 - ((i + 1) * 4));
4568 }
4569 if (__put_user(ccr, &frame->mc_gregs[TARGET_PT_CCR]))
4570 return 1;
4571
4572 /* Save Altivec registers if necessary. */
4573 if (env->insns_flags & PPC_ALTIVEC) {
4574 for (i = 0; i < ARRAY_SIZE(env->avr); i++) {
c227f099
AL		 4575 ppc_avr_t *avr = &env->avr[i];
4576 ppc_avr_t *vreg = &frame->mc_vregs.altivec[i];
bcd4933a
NF		 4577
4578 if (__put_user(avr->u64[0], &vreg->u64[0]) ||
4579 __put_user(avr->u64[1], &vreg->u64[1])) {
4580 return 1;
4581 }
4582 }
4583 /* Set MSR_VR in the saved MSR value to indicate that
4584 frame->mc_vregs contains valid data. */
4585 msr |= MSR_VR;
4586 if (__put_user((uint32_t)env->spr[SPR_VRSAVE],
4587 &frame->mc_vregs.altivec[32].u32[3]))
4588 return 1;
4589 }
4590
4591 /* Save floating point registers. */
4592 if (env->insns_flags & PPC_FLOAT) {
4593 for (i = 0; i < ARRAY_SIZE(env->fpr); i++) {
4594 if (__put_user(env->fpr[i], &frame->mc_fregs[i])) {
4595 return 1;
4596 }
4597 }
4598 if (__put_user((uint64_t) env->fpscr, &frame->mc_fregs[32]))
4599 return 1;
4600 }
4601
4602 /* Save SPE registers. The kernel only saves the high half. */
4603 if (env->insns_flags & PPC_SPE) {
4604#if defined(TARGET_PPC64)
4605 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
4606 if (__put_user(env->gpr[i] >> 32, &frame->mc_vregs.spe[i])) {
4607 return 1;
4608 }
4609 }
4610#else
4611 for (i = 0; i < ARRAY_SIZE(env->gprh); i++) {
4612 if (__put_user(env->gprh[i], &frame->mc_vregs.spe[i])) {
4613 return 1;
4614 }
4615 }
4616#endif
4617 /* Set MSR_SPE in the saved MSR value to indicate that
4618 frame->mc_vregs contains valid data. */
4619 msr |= MSR_SPE;
4620 if (__put_user(env->spe_fscr, &frame->mc_vregs.spe[32]))
4621 return 1;
4622 }
4623
4624 /* Store MSR. */
4625 if (__put_user(msr, &frame->mc_gregs[TARGET_PT_MSR]))
4626 return 1;
4627
4628 /* Set up the sigreturn trampoline: li r0,sigret; sc. */
4629 if (sigret) {
4630 if (__put_user(0x38000000UL | sigret, &frame->tramp[0]) ||
4631 __put_user(0x44000002UL, &frame->tramp[1])) {
4632 return 1;
4633 }
4634 }
4635
4636 return 0;
4637}
4638
05390248 4639static int restore_user_regs(CPUPPCState *env,
bcd4933a
NF		 4640 struct target_mcontext *frame, int sig)
4641{
4642 target_ulong save_r2 = 0;
4643 target_ulong msr;
4644 target_ulong ccr;
4645
4646 int i;
4647
4648 if (!sig) {
4649 save_r2 = env->gpr[2];
4650 }
4651
4652 /* Restore general registers. */
4653 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
4654 if (__get_user(env->gpr[i], &frame->mc_gregs[i])) {
4655 return 1;
4656 }
4657 }
4658 if (__get_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP])
4659 || __get_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR])
4660 || __get_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK])
4661 || __get_user(env->xer, &frame->mc_gregs[TARGET_PT_XER]))
4662 return 1;
4663 if (__get_user(ccr, &frame->mc_gregs[TARGET_PT_CCR]))
4664 return 1;
4665
4666 for (i = 0; i < ARRAY_SIZE(env->crf); i++) {
4667 env->crf[i] = (ccr >> (32 - ((i + 1) * 4))) & 0xf;
4668 }
4669
4670 if (!sig) {
4671 env->gpr[2] = save_r2;
4672 }
4673 /* Restore MSR. */
4674 if (__get_user(msr, &frame->mc_gregs[TARGET_PT_MSR]))
4675 return 1;
4676
4677 /* If doing signal return, restore the previous little-endian mode. */
4678 if (sig)
4679 env->msr = (env->msr & ~MSR_LE) | (msr & MSR_LE);
4680
4681 /* Restore Altivec registers if necessary. */
4682 if (env->insns_flags & PPC_ALTIVEC) {
4683 for (i = 0; i < ARRAY_SIZE(env->avr); i++) {
c227f099
AL		 4684 ppc_avr_t *avr = &env->avr[i];
4685 ppc_avr_t *vreg = &frame->mc_vregs.altivec[i];
bcd4933a
NF		 4686
4687 if (__get_user(avr->u64[0], &vreg->u64[0]) ||
4688 __get_user(avr->u64[1], &vreg->u64[1])) {
4689 return 1;
4690 }
4691 }
4692 /* Set MSR_VEC in the saved MSR value to indicate that
4693 frame->mc_vregs contains valid data. */
4694 if (__get_user(env->spr[SPR_VRSAVE],
4695 (target_ulong *)(&frame->mc_vregs.altivec[32].u32[3])))
4696 return 1;
4697 }
4698
4699 /* Restore floating point registers. */
4700 if (env->insns_flags & PPC_FLOAT) {
4701 uint64_t fpscr;
4702 for (i = 0; i < ARRAY_SIZE(env->fpr); i++) {
4703 if (__get_user(env->fpr[i], &frame->mc_fregs[i])) {
4704 return 1;
4705 }
4706 }
4707 if (__get_user(fpscr, &frame->mc_fregs[32]))
4708 return 1;
4709 env->fpscr = (uint32_t) fpscr;
4710 }
4711
4712 /* Save SPE registers. The kernel only saves the high half. */
4713 if (env->insns_flags & PPC_SPE) {
4714#if defined(TARGET_PPC64)
4715 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
4716 uint32_t hi;
4717
4718 if (__get_user(hi, &frame->mc_vregs.spe[i])) {
4719 return 1;
4720 }
4721 env->gpr[i] = ((uint64_t)hi << 32) | ((uint32_t) env->gpr[i]);
4722 }
4723#else
4724 for (i = 0; i < ARRAY_SIZE(env->gprh); i++) {
4725 if (__get_user(env->gprh[i], &frame->mc_vregs.spe[i])) {
4726 return 1;
4727 }
4728 }
4729#endif
4730 if (__get_user(env->spe_fscr, &frame->mc_vregs.spe[32]))
4731 return 1;
4732 }
4733
4734 return 0;
4735}
4736
4737static void setup_frame(int sig, struct target_sigaction *ka,
05390248 4738 target_sigset_t *set, CPUPPCState *env)
bcd4933a
NF		 4739{
4740 struct target_sigframe *frame;
4741 struct target_sigcontext *sc;
4742 target_ulong frame_addr, newsp;
4743 int err = 0;
4744 int signal;
4745
4746 frame_addr = get_sigframe(ka, env, sizeof(*frame));
4747 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
4748 goto sigsegv;
4749 sc = &frame->sctx;
4750
4751 signal = current_exec_domain_sig(sig);
4752
beb526b1 4753 err |= __put_user(ka->_sa_handler, &sc->handler);
bcd4933a
NF		 4754 err |= __put_user(set->sig[0], &sc->oldmask);
4755#if defined(TARGET_PPC64)
4756 err |= __put_user(set->sig[0] >> 32, &sc->_unused[3]);
4757#else
4758 err |= __put_user(set->sig[1], &sc->_unused[3]);
4759#endif
4760 err |= __put_user(h2g(&frame->mctx), &sc->regs);
4761 err |= __put_user(sig, &sc->signal);
4762
4763 /* Save user regs. */
4764 err |= save_user_regs(env, &frame->mctx, TARGET_NR_sigreturn);
4765
4766 /* The kernel checks for the presence of a VDSO here. We don't
4767 emulate a vdso, so use a sigreturn system call. */
4768 env->lr = (target_ulong) h2g(frame->mctx.tramp);
4769
4770 /* Turn off all fp exceptions. */
4771 env->fpscr = 0;
4772
4773 /* Create a stack frame for the caller of the handler. */
4774 newsp = frame_addr - SIGNAL_FRAMESIZE;
beb526b1 4775 err |= put_user(env->gpr[1], newsp, target_ulong);
bcd4933a
NF		 4776
4777 if (err)
4778 goto sigsegv;
4779
4780 /* Set up registers for signal handler. */
4781 env->gpr[1] = newsp;
4782 env->gpr[3] = signal;
61993a67 4783 env->gpr[4] = frame_addr + offsetof(struct target_sigframe, sctx);
bcd4933a
NF		 4784 env->nip = (target_ulong) ka->_sa_handler;
4785 /* Signal handlers are entered in big-endian mode. */
4786 env->msr &= ~MSR_LE;
4787
4788 unlock_user_struct(frame, frame_addr, 1);
4789 return;
4790
4791sigsegv:
4792 unlock_user_struct(frame, frame_addr, 1);
eeacee4d 4793 qemu_log("segfaulting from setup_frame\n");
66393fb9 4794 force_sig(TARGET_SIGSEGV);
bcd4933a
NF		 4795}
4796
4797static void setup_rt_frame(int sig, struct target_sigaction *ka,
c227f099 4798 target_siginfo_t *info,
05390248 4799 target_sigset_t *set, CPUPPCState *env)
bcd4933a
NF		 4800{
4801 struct target_rt_sigframe *rt_sf;
4802 struct target_mcontext *frame;
4803 target_ulong rt_sf_addr, newsp = 0;
4804 int i, err = 0;
4805 int signal;
4806
4807 rt_sf_addr = get_sigframe(ka, env, sizeof(*rt_sf));
4808 if (!lock_user_struct(VERIFY_WRITE, rt_sf, rt_sf_addr, 1))
4809 goto sigsegv;
4810
4811 signal = current_exec_domain_sig(sig);
4812
4813 err |= copy_siginfo_to_user(&rt_sf->info, info);
4814
60e99246
AJ		 4815 err |= __put_user(0, &rt_sf->uc.tuc_flags);
4816 err |= __put_user(0, &rt_sf->uc.tuc_link);
bcd4933a 4817 err |= __put_user((target_ulong)target_sigaltstack_used.ss_sp,
60e99246 4818 &rt_sf->uc.tuc_stack.ss_sp);
bcd4933a 4819 err |= __put_user(sas_ss_flags(env->gpr[1]),
60e99246 4820 &rt_sf->uc.tuc_stack.ss_flags);
bcd4933a 4821 err |= __put_user(target_sigaltstack_used.ss_size,
60e99246
AJ		 4822 &rt_sf->uc.tuc_stack.ss_size);
4823 err |= __put_user(h2g (&rt_sf->uc.tuc_mcontext),
4824 &rt_sf->uc.tuc_regs);
bcd4933a 4825 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
60e99246 4826 err |= __put_user(set->sig[i], &rt_sf->uc.tuc_sigmask.sig[i]);
bcd4933a
NF		 4827 }
4828
60e99246 4829 frame = &rt_sf->uc.tuc_mcontext;
bcd4933a
NF		 4830 err |= save_user_regs(env, frame, TARGET_NR_rt_sigreturn);
4831
4832 /* The kernel checks for the presence of a VDSO here. We don't
4833 emulate a vdso, so use a sigreturn system call. */
4834 env->lr = (target_ulong) h2g(frame->tramp);
4835
4836 /* Turn off all fp exceptions. */
4837 env->fpscr = 0;
4838
4839 /* Create a stack frame for the caller of the handler. */
4840 newsp = rt_sf_addr - (SIGNAL_FRAMESIZE + 16);
4841 err |= __put_user(env->gpr[1], (target_ulong *)(uintptr_t) newsp);
4842
4843 if (err)
4844 goto sigsegv;
4845
4846 /* Set up registers for signal handler. */
4847 env->gpr[1] = newsp;
4848 env->gpr[3] = (target_ulong) signal;
4849 env->gpr[4] = (target_ulong) h2g(&rt_sf->info);
4850 env->gpr[5] = (target_ulong) h2g(&rt_sf->uc);
4851 env->gpr[6] = (target_ulong) h2g(rt_sf);
4852 env->nip = (target_ulong) ka->_sa_handler;
4853 /* Signal handlers are entered in big-endian mode. */
4854 env->msr &= ~MSR_LE;
4855
4856 unlock_user_struct(rt_sf, rt_sf_addr, 1);
4857 return;
4858
4859sigsegv:
4860 unlock_user_struct(rt_sf, rt_sf_addr, 1);
eeacee4d 4861 qemu_log("segfaulting from setup_rt_frame\n");
66393fb9 4862 force_sig(TARGET_SIGSEGV);
bcd4933a
NF		 4863
4864}
4865
05390248 4866long do_sigreturn(CPUPPCState *env)
bcd4933a
NF		 4867{
4868 struct target_sigcontext *sc = NULL;
4869 struct target_mcontext *sr = NULL;
b04636f8 4870 target_ulong sr_addr = 0, sc_addr;
bcd4933a 4871 sigset_t blocked;
c227f099 4872 target_sigset_t set;
bcd4933a
NF		 4873
4874 sc_addr = env->gpr[1] + SIGNAL_FRAMESIZE;
4875 if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1))
4876 goto sigsegv;
4877
4878#if defined(TARGET_PPC64)
4879 set.sig[0] = sc->oldmask + ((long)(sc->_unused[3]) << 32);
4880#else
4881 if(__get_user(set.sig[0], &sc->oldmask) ||
4882 __get_user(set.sig[1], &sc->_unused[3]))
4883 goto sigsegv;
4884#endif
4885 target_to_host_sigset_internal(&blocked, &set);
4886 sigprocmask(SIG_SETMASK, &blocked, NULL);
4887
4888 if (__get_user(sr_addr, &sc->regs))
4889 goto sigsegv;
4890 if (!lock_user_struct(VERIFY_READ, sr, sr_addr, 1))
4891 goto sigsegv;
4892 if (restore_user_regs(env, sr, 1))
4893 goto sigsegv;
4894
4895 unlock_user_struct(sr, sr_addr, 1);
4896 unlock_user_struct(sc, sc_addr, 1);
4897 return -TARGET_QEMU_ESIGRETURN;
4898
4899sigsegv:
4900 unlock_user_struct(sr, sr_addr, 1);
4901 unlock_user_struct(sc, sc_addr, 1);
eeacee4d 4902 qemu_log("segfaulting from do_sigreturn\n");
66393fb9 4903 force_sig(TARGET_SIGSEGV);
bcd4933a
NF		 4904 return 0;
4905}
4906
4907/* See arch/powerpc/kernel/signal_32.c. */
05390248 4908static int do_setcontext(struct target_ucontext *ucp, CPUPPCState *env, int sig)
bcd4933a
NF		 4909{
4910 struct target_mcontext *mcp;
4911 target_ulong mcp_addr;
4912 sigset_t blocked;
c227f099 4913 target_sigset_t set;
bcd4933a 4914
60e99246 4915 if (copy_from_user(&set, h2g(ucp) + offsetof(struct target_ucontext, tuc_sigmask),
bcd4933a
NF		 4916 sizeof (set)))
4917 return 1;
4918
4919#if defined(TARGET_PPC64)
4920 fprintf (stderr, "do_setcontext: not implemented\n");
4921 return 0;
4922#else
60e99246 4923 if (__get_user(mcp_addr, &ucp->tuc_regs))
bcd4933a
NF		 4924 return 1;
4925
4926 if (!lock_user_struct(VERIFY_READ, mcp, mcp_addr, 1))
4927 return 1;
4928
4929 target_to_host_sigset_internal(&blocked, &set);
4930 sigprocmask(SIG_SETMASK, &blocked, NULL);
4931 if (restore_user_regs(env, mcp, sig))
4932 goto sigsegv;
4933
4934 unlock_user_struct(mcp, mcp_addr, 1);
4935 return 0;
4936
4937sigsegv:
4938 unlock_user_struct(mcp, mcp_addr, 1);
4939 return 1;
4940#endif
4941}
4942
05390248 4943long do_rt_sigreturn(CPUPPCState *env)
bcd4933a
NF		 4944{
4945 struct target_rt_sigframe *rt_sf = NULL;
4946 target_ulong rt_sf_addr;
4947
4948 rt_sf_addr = env->gpr[1] + SIGNAL_FRAMESIZE + 16;
4949 if (!lock_user_struct(VERIFY_READ, rt_sf, rt_sf_addr, 1))
4950 goto sigsegv;
4951
4952 if (do_setcontext(&rt_sf->uc, env, 1))
4953 goto sigsegv;
4954
4955 do_sigaltstack(rt_sf_addr
60e99246 4956 + offsetof(struct target_rt_sigframe, uc.tuc_stack),
bcd4933a
NF		 4957 0, env->gpr[1]);
4958
4959 unlock_user_struct(rt_sf, rt_sf_addr, 1);
4960 return -TARGET_QEMU_ESIGRETURN;
4961
4962sigsegv:
4963 unlock_user_struct(rt_sf, rt_sf_addr, 1);
eeacee4d 4964 qemu_log("segfaulting from do_rt_sigreturn\n");
66393fb9 4965 force_sig(TARGET_SIGSEGV);
bcd4933a
NF		 4966 return 0;
4967}
4968
492a8744
LV		 4969#elif defined(TARGET_M68K)
4970
4971struct target_sigcontext {
4972 abi_ulong sc_mask;
4973 abi_ulong sc_usp;
4974 abi_ulong sc_d0;
4975 abi_ulong sc_d1;
4976 abi_ulong sc_a0;
4977 abi_ulong sc_a1;
4978 unsigned short sc_sr;
4979 abi_ulong sc_pc;
4980};
4981
4982struct target_sigframe
4983{
4984 abi_ulong pretcode;
4985 int sig;
4986 int code;
4987 abi_ulong psc;
4988 char retcode[8];
4989 abi_ulong extramask[TARGET_NSIG_WORDS-1];
4990 struct target_sigcontext sc;
4991};
7181155d 4992
c227f099 4993typedef int target_greg_t;
7181155d 4994#define TARGET_NGREG 18
c227f099 4995typedef target_greg_t target_gregset_t[TARGET_NGREG];
7181155d
LV		 4996
4997typedef struct target_fpregset {
4998 int f_fpcntl[3];
4999 int f_fpregs[8*3];
c227f099 5000} target_fpregset_t;
7181155d
LV		 5001
5002struct target_mcontext {
5003 int version;
c227f099
AL		 5004 target_gregset_t gregs;
5005 target_fpregset_t fpregs;
7181155d
LV		 5006};
5007
5008#define TARGET_MCONTEXT_VERSION 2
5009
5010struct target_ucontext {
60e99246
AJ		 5011 abi_ulong tuc_flags;
5012 abi_ulong tuc_link;
5013 target_stack_t tuc_stack;
5014 struct target_mcontext tuc_mcontext;
5015 abi_long tuc_filler[80];
5016 target_sigset_t tuc_sigmask;
7181155d
LV		 5017};
5018
5019struct target_rt_sigframe
5020{
5021 abi_ulong pretcode;
5022 int sig;
5023 abi_ulong pinfo;
5024 abi_ulong puc;
5025 char retcode[8];
5026 struct target_siginfo info;
5027 struct target_ucontext uc;
5028};
492a8744
LV		 5029
5030static int
05390248
AF		 5031setup_sigcontext(struct target_sigcontext *sc, CPUM68KState *env,
5032 abi_ulong mask)
492a8744
LV		 5033{
5034 int err = 0;
5035
5036 err |= __put_user(mask, &sc->sc_mask);
5037 err |= __put_user(env->aregs[7], &sc->sc_usp);
5038 err |= __put_user(env->dregs[0], &sc->sc_d0);
5039 err |= __put_user(env->dregs[1], &sc->sc_d1);
5040 err |= __put_user(env->aregs[0], &sc->sc_a0);
5041 err |= __put_user(env->aregs[1], &sc->sc_a1);
5042 err |= __put_user(env->sr, &sc->sc_sr);
5043 err |= __put_user(env->pc, &sc->sc_pc);
5044
5045 return err;
5046}
5047
5048static int
05390248 5049restore_sigcontext(CPUM68KState *env, struct target_sigcontext *sc, int *pd0)
492a8744
LV		 5050{
5051 int err = 0;
5052 int temp;
5053
5054 err |= __get_user(env->aregs[7], &sc->sc_usp);
5055 err |= __get_user(env->dregs[1], &sc->sc_d1);
5056 err |= __get_user(env->aregs[0], &sc->sc_a0);
5057 err |= __get_user(env->aregs[1], &sc->sc_a1);
5058 err |= __get_user(env->pc, &sc->sc_pc);
5059 err |= __get_user(temp, &sc->sc_sr);
5060 env->sr = (env->sr & 0xff00) | (temp & 0xff);
5061
5062 *pd0 = tswapl(sc->sc_d0);
5063
5064 return err;
5065}
5066
5067/*
5068 * Determine which stack to use..
5069 */
5070static inline abi_ulong
05390248
AF		 5071get_sigframe(struct target_sigaction *ka, CPUM68KState *regs,
5072 size_t frame_size)
492a8744
LV		 5073{
5074 unsigned long sp;
5075
5076 sp = regs->aregs[7];
5077
5078 /* This is the X/Open sanctioned signal stack switching. */
5079 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) {
5080 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
5081 }
5082
5083 return ((sp - frame_size) & -8UL);
5084}
5085
5086static void setup_frame(int sig, struct target_sigaction *ka,
05390248 5087 target_sigset_t *set, CPUM68KState *env)
492a8744
LV		 5088{
5089 struct target_sigframe *frame;
5090 abi_ulong frame_addr;
5091 abi_ulong retcode_addr;
5092 abi_ulong sc_addr;
5093 int err = 0;
5094 int i;
5095
5096 frame_addr = get_sigframe(ka, env, sizeof *frame);
5097 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
5098 goto give_sigsegv;
5099
5100 err |= __put_user(sig, &frame->sig);
5101
5102 sc_addr = frame_addr + offsetof(struct target_sigframe, sc);
5103 err |= __put_user(sc_addr, &frame->psc);
5104
5105 err |= setup_sigcontext(&frame->sc, env, set->sig[0]);
5106 if (err)
5107 goto give_sigsegv;
5108
5109 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
5110 if (__put_user(set->sig[i], &frame->extramask[i - 1]))
5111 goto give_sigsegv;
5112 }
5113
5114 /* Set up to return from userspace. */
5115
5116 retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode);
5117 err |= __put_user(retcode_addr, &frame->pretcode);
5118
5119 /* moveq #,d0; trap #0 */
5120
5121 err |= __put_user(0x70004e40 + (TARGET_NR_sigreturn << 16),
5122 (long *)(frame->retcode));
5123
5124 if (err)
5125 goto give_sigsegv;
5126
5127 /* Set up to return from userspace */
5128
5129 env->aregs[7] = frame_addr;
5130 env->pc = ka->_sa_handler;
5131
5132 unlock_user_struct(frame, frame_addr, 1);
5133 return;
5134
5135give_sigsegv:
5136 unlock_user_struct(frame, frame_addr, 1);
66393fb9 5137 force_sig(TARGET_SIGSEGV);
492a8744
LV		 5138}
5139
7181155d 5140static inline int target_rt_setup_ucontext(struct target_ucontext *uc,
05390248 5141 CPUM68KState *env)
7181155d 5142{
60e99246 5143 target_greg_t *gregs = uc->tuc_mcontext.gregs;
7181155d
LV		 5144 int err;
5145
60e99246 5146 err = __put_user(TARGET_MCONTEXT_VERSION, &uc->tuc_mcontext.version);
7181155d
LV		 5147 err |= __put_user(env->dregs[0], &gregs[0]);
5148 err |= __put_user(env->dregs[1], &gregs[1]);
5149 err |= __put_user(env->dregs[2], &gregs[2]);
5150 err |= __put_user(env->dregs[3], &gregs[3]);
5151 err |= __put_user(env->dregs[4], &gregs[4]);
5152 err |= __put_user(env->dregs[5], &gregs[5]);
5153 err |= __put_user(env->dregs[6], &gregs[6]);
5154 err |= __put_user(env->dregs[7], &gregs[7]);
5155 err |= __put_user(env->aregs[0], &gregs[8]);
5156 err |= __put_user(env->aregs[1], &gregs[9]);
5157 err |= __put_user(env->aregs[2], &gregs[10]);
5158 err |= __put_user(env->aregs[3], &gregs[11]);
5159 err |= __put_user(env->aregs[4], &gregs[12]);
5160 err |= __put_user(env->aregs[5], &gregs[13]);
5161 err |= __put_user(env->aregs[6], &gregs[14]);
5162 err |= __put_user(env->aregs[7], &gregs[15]);
5163 err |= __put_user(env->pc, &gregs[16]);
5164 err |= __put_user(env->sr, &gregs[17]);
5165
5166 return err;
5167}
5168
05390248 5169static inline int target_rt_restore_ucontext(CPUM68KState *env,
7181155d
LV		 5170 struct target_ucontext *uc,
5171 int *pd0)
5172{
5173 int temp;
5174 int err;
60e99246 5175 target_greg_t *gregs = uc->tuc_mcontext.gregs;
7181155d 5176
60e99246 5177 err = __get_user(temp, &uc->tuc_mcontext.version);
7181155d
LV		 5178 if (temp != TARGET_MCONTEXT_VERSION)
5179 goto badframe;
5180
5181 /* restore passed registers */
5182 err |= __get_user(env->dregs[0], &gregs[0]);
5183 err |= __get_user(env->dregs[1], &gregs[1]);
5184 err |= __get_user(env->dregs[2], &gregs[2]);
5185 err |= __get_user(env->dregs[3], &gregs[3]);
5186 err |= __get_user(env->dregs[4], &gregs[4]);
5187 err |= __get_user(env->dregs[5], &gregs[5]);
5188 err |= __get_user(env->dregs[6], &gregs[6]);
5189 err |= __get_user(env->dregs[7], &gregs[7]);
5190 err |= __get_user(env->aregs[0], &gregs[8]);
5191 err |= __get_user(env->aregs[1], &gregs[9]);
5192 err |= __get_user(env->aregs[2], &gregs[10]);
5193 err |= __get_user(env->aregs[3], &gregs[11]);
5194 err |= __get_user(env->aregs[4], &gregs[12]);
5195 err |= __get_user(env->aregs[5], &gregs[13]);
5196 err |= __get_user(env->aregs[6], &gregs[14]);
5197 err |= __get_user(env->aregs[7], &gregs[15]);
5198 err |= __get_user(env->pc, &gregs[16]);
5199 err |= __get_user(temp, &gregs[17]);
5200 env->sr = (env->sr & 0xff00) | (temp & 0xff);
5201
5202 *pd0 = env->dregs[0];
5203 return err;
5204
5205badframe:
5206 return 1;
5207}
5208
492a8744 5209static void setup_rt_frame(int sig, struct target_sigaction *ka,
c227f099 5210 target_siginfo_t *info,
05390248 5211 target_sigset_t *set, CPUM68KState *env)
492a8744 5212{
7181155d
LV		 5213 struct target_rt_sigframe *frame;
5214 abi_ulong frame_addr;
5215 abi_ulong retcode_addr;
5216 abi_ulong info_addr;
5217 abi_ulong uc_addr;
5218 int err = 0;
5219 int i;
5220
5221 frame_addr = get_sigframe(ka, env, sizeof *frame);
5222 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
5223 goto give_sigsegv;
5224
5225 err |= __put_user(sig, &frame->sig);
5226
5227 info_addr = frame_addr + offsetof(struct target_rt_sigframe, info);
5228 err |= __put_user(info_addr, &frame->pinfo);
5229
5230 uc_addr = frame_addr + offsetof(struct target_rt_sigframe, uc);
5231 err |= __put_user(uc_addr, &frame->puc);
5232
5233 err |= copy_siginfo_to_user(&frame->info, info);
5234
5235 /* Create the ucontext */
5236
60e99246
AJ		 5237 err |= __put_user(0, &frame->uc.tuc_flags);
5238 err |= __put_user(0, &frame->uc.tuc_link);
7181155d 5239 err |= __put_user(target_sigaltstack_used.ss_sp,
60e99246 5240 &frame->uc.tuc_stack.ss_sp);
7181155d 5241 err |= __put_user(sas_ss_flags(env->aregs[7]),
60e99246 5242 &frame->uc.tuc_stack.ss_flags);
7181155d 5243 err |= __put_user(target_sigaltstack_used.ss_size,
60e99246 5244 &frame->uc.tuc_stack.ss_size);
7181155d
LV		 5245 err |= target_rt_setup_ucontext(&frame->uc, env);
5246
5247 if (err)
5248 goto give_sigsegv;
5249
5250 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
60e99246 5251 if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
7181155d
LV		 5252 goto give_sigsegv;
5253 }
5254
5255 /* Set up to return from userspace. */
5256
5257 retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode);
5258 err |= __put_user(retcode_addr, &frame->pretcode);
5259
5260 /* moveq #,d0; notb d0; trap #0 */
5261
5262 err |= __put_user(0x70004600 + ((TARGET_NR_rt_sigreturn ^ 0xff) << 16),
5263 (long *)(frame->retcode + 0));
5264 err |= __put_user(0x4e40, (short *)(frame->retcode + 4));
5265
5266 if (err)
5267 goto give_sigsegv;
5268
5269 /* Set up to return from userspace */
5270
5271 env->aregs[7] = frame_addr;
5272 env->pc = ka->_sa_handler;
5273
5274 unlock_user_struct(frame, frame_addr, 1);
5275 return;
5276
5277give_sigsegv:
5278 unlock_user_struct(frame, frame_addr, 1);
66393fb9 5279 force_sig(TARGET_SIGSEGV);
492a8744
LV		 5280}
5281
05390248 5282long do_sigreturn(CPUM68KState *env)
492a8744
LV		 5283{
5284 struct target_sigframe *frame;
5285 abi_ulong frame_addr = env->aregs[7] - 4;
c227f099 5286 target_sigset_t target_set;
492a8744
LV		 5287 sigset_t set;
5288 int d0, i;
5289
5290 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
5291 goto badframe;
5292
5293 /* set blocked signals */
5294
5295 if (__get_user(target_set.sig[0], &frame->sc.sc_mask))
5296 goto badframe;
5297
5298 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
5299 if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
5300 goto badframe;
5301 }
5302
5303 target_to_host_sigset_internal(&set, &target_set);
5304 sigprocmask(SIG_SETMASK, &set, NULL);
5305
5306 /* restore registers */
5307
5308 if (restore_sigcontext(env, &frame->sc, &d0))
5309 goto badframe;
5310
5311 unlock_user_struct(frame, frame_addr, 0);
5312 return d0;
5313
5314badframe:
5315 unlock_user_struct(frame, frame_addr, 0);
5316 force_sig(TARGET_SIGSEGV);
5317 return 0;
5318}
5319
05390248 5320long do_rt_sigreturn(CPUM68KState *env)
492a8744 5321{
7181155d
LV		 5322 struct target_rt_sigframe *frame;
5323 abi_ulong frame_addr = env->aregs[7] - 4;
c227f099 5324 target_sigset_t target_set;
7181155d
LV		 5325 sigset_t set;
5326 int d0;
5327
5328 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
5329 goto badframe;
5330
5331 target_to_host_sigset_internal(&set, &target_set);
5332 sigprocmask(SIG_SETMASK, &set, NULL);
5333
5334 /* restore registers */
5335
5336 if (target_rt_restore_ucontext(env, &frame->uc, &d0))
5337 goto badframe;
5338
5339 if (do_sigaltstack(frame_addr +
60e99246 5340 offsetof(struct target_rt_sigframe, uc.tuc_stack),
7181155d
LV		 5341 0, get_sp_from_cpustate(env)) == -EFAULT)
5342 goto badframe;
5343
5344 unlock_user_struct(frame, frame_addr, 0);
5345 return d0;
5346
5347badframe:
5348 unlock_user_struct(frame, frame_addr, 0);
5349 force_sig(TARGET_SIGSEGV);
5350 return 0;
492a8744
LV		 5351}
5352
6049f4f8
RH		 5353#elif defined(TARGET_ALPHA)
5354
5355struct target_sigcontext {
5356 abi_long sc_onstack;
5357 abi_long sc_mask;
5358 abi_long sc_pc;
5359 abi_long sc_ps;
5360 abi_long sc_regs[32];
5361 abi_long sc_ownedfp;
5362 abi_long sc_fpregs[32];
5363 abi_ulong sc_fpcr;
5364 abi_ulong sc_fp_control;
5365 abi_ulong sc_reserved1;
5366 abi_ulong sc_reserved2;
5367 abi_ulong sc_ssize;
5368 abi_ulong sc_sbase;
5369 abi_ulong sc_traparg_a0;
5370 abi_ulong sc_traparg_a1;
5371 abi_ulong sc_traparg_a2;
5372 abi_ulong sc_fp_trap_pc;
5373 abi_ulong sc_fp_trigger_sum;
5374 abi_ulong sc_fp_trigger_inst;
5375};
5376
5377struct target_ucontext {
60e99246
AJ		 5378 abi_ulong tuc_flags;
5379 abi_ulong tuc_link;
5380 abi_ulong tuc_osf_sigmask;
5381 target_stack_t tuc_stack;
5382 struct target_sigcontext tuc_mcontext;
5383 target_sigset_t tuc_sigmask;
6049f4f8
RH		 5384};
5385
5386struct target_sigframe {
5387 struct target_sigcontext sc;
5388 unsigned int retcode[3];
5389};
5390
5391struct target_rt_sigframe {
5392 target_siginfo_t info;
5393 struct target_ucontext uc;
5394 unsigned int retcode[3];
5395};
5396
5397#define INSN_MOV_R30_R16 0x47fe0410
5398#define INSN_LDI_R0 0x201f0000
5399#define INSN_CALLSYS 0x00000083
5400
05390248 5401static int setup_sigcontext(struct target_sigcontext *sc, CPUAlphaState *env,
6049f4f8
RH		 5402 abi_ulong frame_addr, target_sigset_t *set)
5403{
5404 int i, err = 0;
5405
5406 err |= __put_user(on_sig_stack(frame_addr), &sc->sc_onstack);
5407 err |= __put_user(set->sig[0], &sc->sc_mask);
5408 err |= __put_user(env->pc, &sc->sc_pc);
5409 err |= __put_user(8, &sc->sc_ps);
5410
5411 for (i = 0; i < 31; ++i) {
5412 err |= __put_user(env->ir[i], &sc->sc_regs[i]);
5413 }
5414 err |= __put_user(0, &sc->sc_regs[31]);
5415
5416 for (i = 0; i < 31; ++i) {
5417 err |= __put_user(env->fir[i], &sc->sc_fpregs[i]);
5418 }
5419 err |= __put_user(0, &sc->sc_fpregs[31]);
5420 err |= __put_user(cpu_alpha_load_fpcr(env), &sc->sc_fpcr);
5421
5422 err |= __put_user(0, &sc->sc_traparg_a0); /* FIXME */
5423 err |= __put_user(0, &sc->sc_traparg_a1); /* FIXME */
5424 err |= __put_user(0, &sc->sc_traparg_a2); /* FIXME */
5425
5426 return err;
5427}
5428
05390248
AF		 5429static int restore_sigcontext(CPUAlphaState *env,
5430 struct target_sigcontext *sc)
6049f4f8
RH		 5431{
5432 uint64_t fpcr;
5433 int i, err = 0;
5434
5435 err |= __get_user(env->pc, &sc->sc_pc);
5436
5437 for (i = 0; i < 31; ++i) {
5438 err |= __get_user(env->ir[i], &sc->sc_regs[i]);
5439 }
5440 for (i = 0; i < 31; ++i) {
5441 err |= __get_user(env->fir[i], &sc->sc_fpregs[i]);
5442 }
5443
5444 err |= __get_user(fpcr, &sc->sc_fpcr);
5445 cpu_alpha_store_fpcr(env, fpcr);
5446
5447 return err;
5448}
5449
5450static inline abi_ulong get_sigframe(struct target_sigaction *sa,
05390248
AF		 5451 CPUAlphaState *env,
5452 unsigned long framesize)
6049f4f8
RH		 5453{
5454 abi_ulong sp = env->ir[IR_SP];
5455
5456 /* This is the X/Open sanctioned signal stack switching. */
5457 if ((sa->sa_flags & TARGET_SA_ONSTACK) != 0 && !sas_ss_flags(sp)) {
5458 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
5459 }
5460 return (sp - framesize) & -32;
5461}
5462
5463static void setup_frame(int sig, struct target_sigaction *ka,
05390248 5464 target_sigset_t *set, CPUAlphaState *env)
6049f4f8
RH		 5465{
5466 abi_ulong frame_addr, r26;
5467 struct target_sigframe *frame;
5468 int err = 0;
5469
5470 frame_addr = get_sigframe(ka, env, sizeof(*frame));
5471 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
5472 goto give_sigsegv;
5473 }
5474
5475 err |= setup_sigcontext(&frame->sc, env, frame_addr, set);
5476
5477 if (ka->sa_restorer) {
5478 r26 = ka->sa_restorer;
5479 } else {
5480 err |= __put_user(INSN_MOV_R30_R16, &frame->retcode[0]);
5481 err |= __put_user(INSN_LDI_R0 + TARGET_NR_sigreturn,
5482 &frame->retcode[1]);
5483 err |= __put_user(INSN_CALLSYS, &frame->retcode[2]);
5484 /* imb() */
5485 r26 = frame_addr;
5486 }
5487
5488 unlock_user_struct(frame, frame_addr, 1);
5489
5490 if (err) {
5491 give_sigsegv:
5492 if (sig == TARGET_SIGSEGV) {
5493 ka->_sa_handler = TARGET_SIG_DFL;
5494 }
5495 force_sig(TARGET_SIGSEGV);
5496 }
5497
5498 env->ir[IR_RA] = r26;
5499 env->ir[IR_PV] = env->pc = ka->_sa_handler;
5500 env->ir[IR_A0] = sig;
5501 env->ir[IR_A1] = 0;
5502 env->ir[IR_A2] = frame_addr + offsetof(struct target_sigframe, sc);
5503 env->ir[IR_SP] = frame_addr;
5504}
5505
5506static void setup_rt_frame(int sig, struct target_sigaction *ka,
5507 target_siginfo_t *info,
05390248 5508 target_sigset_t *set, CPUAlphaState *env)
6049f4f8
RH		 5509{
5510 abi_ulong frame_addr, r26;
5511 struct target_rt_sigframe *frame;
5512 int i, err = 0;
5513
5514 frame_addr = get_sigframe(ka, env, sizeof(*frame));
5515 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
5516 goto give_sigsegv;
5517 }
5518
5519 err |= copy_siginfo_to_user(&frame->info, info);
5520
60e99246
AJ		 5521 err |= __put_user(0, &frame->uc.tuc_flags);
5522 err |= __put_user(0, &frame->uc.tuc_link);
5523 err |= __put_user(set->sig[0], &frame->uc.tuc_osf_sigmask);
6049f4f8 5524 err |= __put_user(target_sigaltstack_used.ss_sp,
60e99246 5525 &frame->uc.tuc_stack.ss_sp);
6049f4f8 5526 err |= __put_user(sas_ss_flags(env->ir[IR_SP]),
60e99246 5527 &frame->uc.tuc_stack.ss_flags);
6049f4f8 5528 err |= __put_user(target_sigaltstack_used.ss_size,
60e99246
AJ		 5529 &frame->uc.tuc_stack.ss_size);
5530 err |= setup_sigcontext(&frame->uc.tuc_mcontext, env, frame_addr, set);
6049f4f8 5531 for (i = 0; i < TARGET_NSIG_WORDS; ++i) {
60e99246 5532 err |= __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
6049f4f8
RH		 5533 }
5534
5535 if (ka->sa_restorer) {
5536 r26 = ka->sa_restorer;
5537 } else {
5538 err |= __put_user(INSN_MOV_R30_R16, &frame->retcode[0]);
5539 err |= __put_user(INSN_LDI_R0 + TARGET_NR_rt_sigreturn,
5540 &frame->retcode[1]);
5541 err |= __put_user(INSN_CALLSYS, &frame->retcode[2]);
5542 /* imb(); */
5543 r26 = frame_addr;
5544 }
5545
5546 if (err) {
5547 give_sigsegv:
5548 if (sig == TARGET_SIGSEGV) {
5549 ka->_sa_handler = TARGET_SIG_DFL;
5550 }
5551 force_sig(TARGET_SIGSEGV);
5552 }
5553
5554 env->ir[IR_RA] = r26;
5555 env->ir[IR_PV] = env->pc = ka->_sa_handler;
5556 env->ir[IR_A0] = sig;
5557 env->ir[IR_A1] = frame_addr + offsetof(struct target_rt_sigframe, info);
5558 env->ir[IR_A2] = frame_addr + offsetof(struct target_rt_sigframe, uc);
5559 env->ir[IR_SP] = frame_addr;
5560}
5561
05390248 5562long do_sigreturn(CPUAlphaState *env)
6049f4f8
RH		 5563{
5564 struct target_sigcontext *sc;
5565 abi_ulong sc_addr = env->ir[IR_A0];
5566 target_sigset_t target_set;
5567 sigset_t set;
5568
5569 if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1)) {
5570 goto badframe;
5571 }
5572
5573 target_sigemptyset(&target_set);
5574 if (__get_user(target_set.sig[0], &sc->sc_mask)) {
5575 goto badframe;
5576 }
5577
5578 target_to_host_sigset_internal(&set, &target_set);
5579 sigprocmask(SIG_SETMASK, &set, NULL);
5580
5581 if (restore_sigcontext(env, sc)) {
5582 goto badframe;
5583 }
5584 unlock_user_struct(sc, sc_addr, 0);
5585 return env->ir[IR_V0];
5586
5587 badframe:
5588 unlock_user_struct(sc, sc_addr, 0);
5589 force_sig(TARGET_SIGSEGV);
5590}
5591
05390248 5592long do_rt_sigreturn(CPUAlphaState *env)
6049f4f8
RH		 5593{
5594 abi_ulong frame_addr = env->ir[IR_A0];
5595 struct target_rt_sigframe *frame;
5596 sigset_t set;
5597
5598 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
5599 goto badframe;
5600 }
60e99246 5601 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
6049f4f8
RH		 5602 sigprocmask(SIG_SETMASK, &set, NULL);
5603
60e99246 5604 if (restore_sigcontext(env, &frame->uc.tuc_mcontext)) {
6049f4f8
RH		 5605 goto badframe;
5606 }
5607 if (do_sigaltstack(frame_addr + offsetof(struct target_rt_sigframe,
60e99246 5608 uc.tuc_stack),
6049f4f8
RH		 5609 0, env->ir[IR_SP]) == -EFAULT) {
5610 goto badframe;
5611 }
5612
5613 unlock_user_struct(frame, frame_addr, 0);
5614 return env->ir[IR_V0];
5615
5616
5617 badframe:
5618 unlock_user_struct(frame, frame_addr, 0);
5619 force_sig(TARGET_SIGSEGV);
5620}
5621
b346ff46
FB		 5622#else
5623
624f7979 5624static void setup_frame(int sig, struct target_sigaction *ka,
9349b4f9 5625 target_sigset_t *set, CPUArchState *env)
b346ff46
FB		 5626{
5627 fprintf(stderr, "setup_frame: not implemented\n");
5628}
5629
624f7979 5630static void setup_rt_frame(int sig, struct target_sigaction *ka,
c227f099 5631 target_siginfo_t *info,
9349b4f9 5632 target_sigset_t *set, CPUArchState *env)
b346ff46
FB		 5633{
5634 fprintf(stderr, "setup_rt_frame: not implemented\n");
5635}
5636
9349b4f9 5637long do_sigreturn(CPUArchState *env)
b346ff46
FB		 5638{
5639 fprintf(stderr, "do_sigreturn: not implemented\n");
f8b0aa25 5640 return -TARGET_ENOSYS;
b346ff46
FB		 5641}
5642
9349b4f9 5643long do_rt_sigreturn(CPUArchState *env)
b346ff46
FB		 5644{
5645 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
f8b0aa25 5646 return -TARGET_ENOSYS;
b346ff46
FB		 5647}
5648
66fb9763
FB		 5649#endif
5650
9349b4f9 5651void process_pending_signals(CPUArchState *cpu_env)
66fb9763 5652{
db6b81d4 5653 CPUState *cpu = ENV_GET_CPU(cpu_env);
66fb9763 5654 int sig;
992f48a0 5655 abi_ulong handler;
9de5e440 5656 sigset_t set, old_set;
c227f099 5657 target_sigset_t target_old_set;
624f7979
PB		 5658 struct emulated_sigtable *k;
5659 struct target_sigaction *sa;
66fb9763 5660 struct sigqueue *q;
624f7979 5661 TaskState *ts = cpu_env->opaque;
3b46e624 5662
624f7979 5663 if (!ts->signal_pending)
31e31b8a
FB		 5664 return;
5665
624f7979
PB		 5666 /* FIXME: This is not threadsafe. */
5667 k = ts->sigtab;
66fb9763
FB		 5668 for(sig = 1; sig <= TARGET_NSIG; sig++) {
5669 if (k->pending)
31e31b8a 5670 goto handle_signal;
66fb9763 5671 k++;
31e31b8a
FB		 5672 }
5673 /* if no signal is pending, just return */
624f7979 5674 ts->signal_pending = 0;
31e31b8a 5675 return;
66fb9763 5676
31e31b8a 5677 handle_signal:
66fb9763 5678#ifdef DEBUG_SIGNAL
bc8a22cc 5679 fprintf(stderr, "qemu: process signal %d\n", sig);
66fb9763
FB		 5680#endif
5681 /* dequeue signal */
5682 q = k->first;
5683 k->first = q->next;
5684 if (!k->first)
5685 k->pending = 0;
3b46e624 5686
db6b81d4 5687 sig = gdb_handlesig(cpu, sig);
1fddef4b 5688 if (!sig) {
ca587a8e
AJ		 5689 sa = NULL;
5690 handler = TARGET_SIG_IGN;
5691 } else {
5692 sa = &sigact_table[sig - 1];
5693 handler = sa->_sa_handler;
1fddef4b 5694 }
66fb9763 5695
66fb9763 5696 if (handler == TARGET_SIG_DFL) {
ca587a8e
AJ		 5697 /* default handler : ignore some signal. The other are job control or fatal */
5698 if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) {
5699 kill(getpid(),SIGSTOP);
5700 } else if (sig != TARGET_SIGCHLD &&
5701 sig != TARGET_SIGURG &&
5702 sig != TARGET_SIGWINCH &&
5703 sig != TARGET_SIGCONT) {
66fb9763
FB		 5704 force_sig(sig);
5705 }
5706 } else if (handler == TARGET_SIG_IGN) {
5707 /* ignore sig */
5708 } else if (handler == TARGET_SIG_ERR) {
5709 force_sig(sig);
5710 } else {
9de5e440 5711 /* compute the blocked signals during the handler execution */
624f7979 5712 target_to_host_sigset(&set, &sa->sa_mask);
9de5e440
FB		 5713 /* SA_NODEFER indicates that the current signal should not be
5714 blocked during the handler */
624f7979 5715 if (!(sa->sa_flags & TARGET_SA_NODEFER))
9de5e440 5716 sigaddset(&set, target_to_host_signal(sig));
3b46e624 5717
9de5e440
FB		 5718 /* block signals in the handler using Linux */
5719 sigprocmask(SIG_BLOCK, &set, &old_set);
5720 /* save the previous blocked signal state to restore it at the
5721 end of the signal execution (see do_sigreturn) */
9231944d 5722 host_to_target_sigset_internal(&target_old_set, &old_set);
9de5e440 5723
bc8a22cc 5724 /* if the CPU is in VM86 mode, we restore the 32 bit values */
84409ddb 5725#if defined(TARGET_I386) && !defined(TARGET_X86_64)
bc8a22cc
FB		 5726 {
5727 CPUX86State *env = cpu_env;
5728 if (env->eflags & VM_MASK)
5729 save_v86_state(env);
5730 }
5731#endif
9de5e440 5732 /* prepare the stack frame of the virtual CPU */
ff970904
RH		 5733#if defined(TARGET_ABI_MIPSN32) || defined(TARGET_ABI_MIPSN64)
5734 /* These targets do not have traditional signals. */
5735 setup_rt_frame(sig, sa, &q->info, &target_old_set, cpu_env);
5736#else
624f7979
PB		 5737 if (sa->sa_flags & TARGET_SA_SIGINFO)
5738 setup_rt_frame(sig, sa, &q->info, &target_old_set, cpu_env);
66fb9763 5739 else
624f7979 5740 setup_frame(sig, sa, &target_old_set, cpu_env);
ff970904 5741#endif
624f7979
PB		 5742 if (sa->sa_flags & TARGET_SA_RESETHAND)
5743 sa->_sa_handler = TARGET_SIG_DFL;
31e31b8a 5744 }
66fb9763 5745 if (q != &k->info)
624f7979 5746 free_sigqueue(cpu_env, q);
66fb9763 5747}
Qemu copy for testing