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