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