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