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