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