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