?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ui: remove unreachable code in vnc_update_client
[qemu/ar7.git] / linux-user / signal.c
blobf85f0dd780253da47e383f3f25e055f177f9ad22
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 #ifdef TARGET_WORDS_BIGENDIAN
1491 __put_user(env->vfp.regs[i * 2], &aux->fpsimd.vregs[i * 2 + 1]);
1492 __put_user(env->vfp.regs[i * 2 + 1], &aux->fpsimd.vregs[i * 2]);
1493 #else
1494 __put_user(env->vfp.regs[i * 2], &aux->fpsimd.vregs[i * 2]);
1495 __put_user(env->vfp.regs[i * 2 + 1], &aux->fpsimd.vregs[i * 2 + 1]);
1496 #endif
1497 }
1498 __put_user(vfp_get_fpsr(env), &aux->fpsimd.fpsr);
1499 __put_user(vfp_get_fpcr(env), &aux->fpsimd.fpcr);
1500 __put_user(TARGET_FPSIMD_MAGIC, &aux->fpsimd.head.magic);
1501 __put_user(sizeof(struct target_fpsimd_context),
1502 &aux->fpsimd.head.size);
1503
1504 /* set the "end" magic */
1505 __put_user(0, &aux->end.magic);
1506 __put_user(0, &aux->end.size);
1507
1508 return 0;
1509 }
1510
1511 static int target_restore_sigframe(CPUARMState *env,
1512 struct target_rt_sigframe *sf)
1513 {
1514 sigset_t set;
1515 int i;
1516 struct target_aux_context *aux =
1517 (struct target_aux_context *)sf->uc.tuc_mcontext.__reserved;
1518 uint32_t magic, size, fpsr, fpcr;
1519 uint64_t pstate;
1520
1521 target_to_host_sigset(&set, &sf->uc.tuc_sigmask);
1522 set_sigmask(&set);
1523
1524 for (i = 0; i < 31; i++) {
1525 __get_user(env->xregs[i], &sf->uc.tuc_mcontext.regs[i]);
1526 }
1527
1528 __get_user(env->xregs[31], &sf->uc.tuc_mcontext.sp);
1529 __get_user(env->pc, &sf->uc.tuc_mcontext.pc);
1530 __get_user(pstate, &sf->uc.tuc_mcontext.pstate);
1531 pstate_write(env, pstate);
1532
1533 __get_user(magic, &aux->fpsimd.head.magic);
1534 __get_user(size, &aux->fpsimd.head.size);
1535
1536 if (magic != TARGET_FPSIMD_MAGIC
1537 || size != sizeof(struct target_fpsimd_context)) {
1538 return 1;
1539 }
1540
1541 for (i = 0; i < 32; i++) {
1542 #ifdef TARGET_WORDS_BIGENDIAN
1543 __get_user(env->vfp.regs[i * 2], &aux->fpsimd.vregs[i * 2 + 1]);
1544 __get_user(env->vfp.regs[i * 2 + 1], &aux->fpsimd.vregs[i * 2]);
1545 #else
1546 __get_user(env->vfp.regs[i * 2], &aux->fpsimd.vregs[i * 2]);
1547 __get_user(env->vfp.regs[i * 2 + 1], &aux->fpsimd.vregs[i * 2 + 1]);
1548 #endif
1549 }
1550 __get_user(fpsr, &aux->fpsimd.fpsr);
1551 vfp_set_fpsr(env, fpsr);
1552 __get_user(fpcr, &aux->fpsimd.fpcr);
1553 vfp_set_fpcr(env, fpcr);
1554
1555 return 0;
1556 }
1557
1558 static abi_ulong get_sigframe(struct target_sigaction *ka, CPUARMState *env)
1559 {
1560 abi_ulong sp;
1561
1562 sp = env->xregs[31];
1563
1564 /*
1565 * This is the X/Open sanctioned signal stack switching.
1566 */
1567 if ((ka->sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp)) {
1568 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
1569 }
1570
1571 sp = (sp - sizeof(struct target_rt_sigframe)) & ~15;
1572
1573 return sp;
1574 }
1575
1576 static void target_setup_frame(int usig, struct target_sigaction *ka,
1577 target_siginfo_t *info, target_sigset_t *set,
1578 CPUARMState *env)
1579 {
1580 struct target_rt_sigframe *frame;
1581 abi_ulong frame_addr, return_addr;
1582
1583 frame_addr = get_sigframe(ka, env);
1584 trace_user_setup_frame(env, frame_addr);
1585 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
1586 goto give_sigsegv;
1587 }
1588
1589 __put_user(0, &frame->uc.tuc_flags);
1590 __put_user(0, &frame->uc.tuc_link);
1591
1592 __put_user(target_sigaltstack_used.ss_sp,
1593 &frame->uc.tuc_stack.ss_sp);
1594 __put_user(sas_ss_flags(env->xregs[31]),
1595 &frame->uc.tuc_stack.ss_flags);
1596 __put_user(target_sigaltstack_used.ss_size,
1597 &frame->uc.tuc_stack.ss_size);
1598 target_setup_sigframe(frame, env, set);
1599 if (ka->sa_flags & TARGET_SA_RESTORER) {
1600 return_addr = ka->sa_restorer;
1601 } else {
1602 /*
1603 * mov x8,#__NR_rt_sigreturn; svc #0
1604 * Since these are instructions they need to be put as little-endian
1605 * regardless of target default or current CPU endianness.
1606 */
1607 __put_user_e(0xd2801168, &frame->tramp[0], le);
1608 __put_user_e(0xd4000001, &frame->tramp[1], le);
1609 return_addr = frame_addr + offsetof(struct target_rt_sigframe, tramp);
1610 }
1611 env->xregs[0] = usig;
1612 env->xregs[31] = frame_addr;
1613 env->xregs[29] = env->xregs[31] + offsetof(struct target_rt_sigframe, fp);
1614 env->pc = ka->_sa_handler;
1615 env->xregs[30] = return_addr;
1616 if (info) {
1617 tswap_siginfo(&frame->info, info);
1618 env->xregs[1] = frame_addr + offsetof(struct target_rt_sigframe, info);
1619 env->xregs[2] = frame_addr + offsetof(struct target_rt_sigframe, uc);
1620 }
1621
1622 unlock_user_struct(frame, frame_addr, 1);
1623 return;
1624
1625 give_sigsegv:
1626 unlock_user_struct(frame, frame_addr, 1);
1627 force_sigsegv(usig);
1628 }
1629
1630 static void setup_rt_frame(int sig, struct target_sigaction *ka,
1631 target_siginfo_t *info, target_sigset_t *set,
1632 CPUARMState *env)
1633 {
1634 target_setup_frame(sig, ka, info, set, env);
1635 }
1636
1637 static void setup_frame(int sig, struct target_sigaction *ka,
1638 target_sigset_t *set, CPUARMState *env)
1639 {
1640 target_setup_frame(sig, ka, 0, set, env);
1641 }
1642
1643 long do_rt_sigreturn(CPUARMState *env)
1644 {
1645 struct target_rt_sigframe *frame = NULL;
1646 abi_ulong frame_addr = env->xregs[31];
1647
1648 trace_user_do_rt_sigreturn(env, frame_addr);
1649 if (frame_addr & 15) {
1650 goto badframe;
1651 }
1652
1653 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
1654 goto badframe;
1655 }
1656
1657 if (target_restore_sigframe(env, frame)) {
1658 goto badframe;
1659 }
1660
1661 if (do_sigaltstack(frame_addr +
1662 offsetof(struct target_rt_sigframe, uc.tuc_stack),
1663 0, get_sp_from_cpustate(env)) == -EFAULT) {
1664 goto badframe;
1665 }
1666
1667 unlock_user_struct(frame, frame_addr, 0);
1668 return -TARGET_QEMU_ESIGRETURN;
1669
1670 badframe:
1671 unlock_user_struct(frame, frame_addr, 0);
1672 force_sig(TARGET_SIGSEGV);
1673 return -TARGET_QEMU_ESIGRETURN;
1674 }
1675
1676 long do_sigreturn(CPUARMState *env)
1677 {
1678 return do_rt_sigreturn(env);
1679 }
1680
1681 #elif defined(TARGET_ARM)
1682
1683 struct target_sigcontext {
1684 abi_ulong trap_no;
1685 abi_ulong error_code;
1686 abi_ulong oldmask;
1687 abi_ulong arm_r0;
1688 abi_ulong arm_r1;
1689 abi_ulong arm_r2;
1690 abi_ulong arm_r3;
1691 abi_ulong arm_r4;
1692 abi_ulong arm_r5;
1693 abi_ulong arm_r6;
1694 abi_ulong arm_r7;
1695 abi_ulong arm_r8;
1696 abi_ulong arm_r9;
1697 abi_ulong arm_r10;
1698 abi_ulong arm_fp;
1699 abi_ulong arm_ip;
1700 abi_ulong arm_sp;
1701 abi_ulong arm_lr;
1702 abi_ulong arm_pc;
1703 abi_ulong arm_cpsr;
1704 abi_ulong fault_address;
1705 };
1706
1707 struct target_ucontext_v1 {
1708 abi_ulong tuc_flags;
1709 abi_ulong tuc_link;
1710 target_stack_t tuc_stack;
1711 struct target_sigcontext tuc_mcontext;
1712 target_sigset_t tuc_sigmask; /* mask last for extensibility */
1713 };
1714
1715 struct target_ucontext_v2 {
1716 abi_ulong tuc_flags;
1717 abi_ulong tuc_link;
1718 target_stack_t tuc_stack;
1719 struct target_sigcontext tuc_mcontext;
1720 target_sigset_t tuc_sigmask; /* mask last for extensibility */
1721 char __unused[128 - sizeof(target_sigset_t)];
1722 abi_ulong tuc_regspace[128] __attribute__((__aligned__(8)));
1723 };
1724
1725 struct target_user_vfp {
1726 uint64_t fpregs[32];
1727 abi_ulong fpscr;
1728 };
1729
1730 struct target_user_vfp_exc {
1731 abi_ulong fpexc;
1732 abi_ulong fpinst;
1733 abi_ulong fpinst2;
1734 };
1735
1736 struct target_vfp_sigframe {
1737 abi_ulong magic;
1738 abi_ulong size;
1739 struct target_user_vfp ufp;
1740 struct target_user_vfp_exc ufp_exc;
1741 } __attribute__((__aligned__(8)));
1742
1743 struct target_iwmmxt_sigframe {
1744 abi_ulong magic;
1745 abi_ulong size;
1746 uint64_t regs[16];
1747 /* Note that not all the coprocessor control registers are stored here */
1748 uint32_t wcssf;
1749 uint32_t wcasf;
1750 uint32_t wcgr0;
1751 uint32_t wcgr1;
1752 uint32_t wcgr2;
1753 uint32_t wcgr3;
1754 } __attribute__((__aligned__(8)));
1755
1756 #define TARGET_VFP_MAGIC 0x56465001
1757 #define TARGET_IWMMXT_MAGIC 0x12ef842a
1758
1759 struct sigframe_v1
1760 {
1761 struct target_sigcontext sc;
1762 abi_ulong extramask[TARGET_NSIG_WORDS-1];
1763 abi_ulong retcode;
1764 };
1765
1766 struct sigframe_v2
1767 {
1768 struct target_ucontext_v2 uc;
1769 abi_ulong retcode;
1770 };
1771
1772 struct rt_sigframe_v1
1773 {
1774 abi_ulong pinfo;
1775 abi_ulong puc;
1776 struct target_siginfo info;
1777 struct target_ucontext_v1 uc;
1778 abi_ulong retcode;
1779 };
1780
1781 struct rt_sigframe_v2
1782 {
1783 struct target_siginfo info;
1784 struct target_ucontext_v2 uc;
1785 abi_ulong retcode;
1786 };
1787
1788 #define TARGET_CONFIG_CPU_32 1
1789
1790 /*
1791 * For ARM syscalls, we encode the syscall number into the instruction.
1792 */
1793 #define SWI_SYS_SIGRETURN (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE))
1794 #define SWI_SYS_RT_SIGRETURN (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE))
1795
1796 /*
1797 * For Thumb syscalls, we pass the syscall number via r7. We therefore
1798 * need two 16-bit instructions.
1799 */
1800 #define SWI_THUMB_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn))
1801 #define SWI_THUMB_RT_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn))
1802
1803 static const abi_ulong retcodes[4] = {
1804 SWI_SYS_SIGRETURN, SWI_THUMB_SIGRETURN,
1805 SWI_SYS_RT_SIGRETURN, SWI_THUMB_RT_SIGRETURN
1806 };
1807
1808
1809 static inline int valid_user_regs(CPUARMState *regs)
1810 {
1811 return 1;
1812 }
1813
1814 static void
1815 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
1816 CPUARMState *env, abi_ulong mask)
1817 {
1818 __put_user(env->regs[0], &sc->arm_r0);
1819 __put_user(env->regs[1], &sc->arm_r1);
1820 __put_user(env->regs[2], &sc->arm_r2);
1821 __put_user(env->regs[3], &sc->arm_r3);
1822 __put_user(env->regs[4], &sc->arm_r4);
1823 __put_user(env->regs[5], &sc->arm_r5);
1824 __put_user(env->regs[6], &sc->arm_r6);
1825 __put_user(env->regs[7], &sc->arm_r7);
1826 __put_user(env->regs[8], &sc->arm_r8);
1827 __put_user(env->regs[9], &sc->arm_r9);
1828 __put_user(env->regs[10], &sc->arm_r10);
1829 __put_user(env->regs[11], &sc->arm_fp);
1830 __put_user(env->regs[12], &sc->arm_ip);
1831 __put_user(env->regs[13], &sc->arm_sp);
1832 __put_user(env->regs[14], &sc->arm_lr);
1833 __put_user(env->regs[15], &sc->arm_pc);
1834 #ifdef TARGET_CONFIG_CPU_32
1835 __put_user(cpsr_read(env), &sc->arm_cpsr);
1836 #endif
1837
1838 __put_user(/* current->thread.trap_no */ 0, &sc->trap_no);
1839 __put_user(/* current->thread.error_code */ 0, &sc->error_code);
1840 __put_user(/* current->thread.address */ 0, &sc->fault_address);
1841 __put_user(mask, &sc->oldmask);
1842 }
1843
1844 static inline abi_ulong
1845 get_sigframe(struct target_sigaction *ka, CPUARMState *regs, int framesize)
1846 {
1847 unsigned long sp = regs->regs[13];
1848
1849 /*
1850 * This is the X/Open sanctioned signal stack switching.
1851 */
1852 if ((ka->sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp)) {
1853 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
1854 }
1855 /*
1856 * ATPCS B01 mandates 8-byte alignment
1857 */
1858 return (sp - framesize) & ~7;
1859 }
1860
1861 static void
1862 setup_return(CPUARMState *env, struct target_sigaction *ka,
1863 abi_ulong *rc, abi_ulong frame_addr, int usig, abi_ulong rc_addr)
1864 {
1865 abi_ulong handler = ka->_sa_handler;
1866 abi_ulong retcode;
1867 int thumb = handler & 1;
1868 uint32_t cpsr = cpsr_read(env);
1869
1870 cpsr &= ~CPSR_IT;
1871 if (thumb) {
1872 cpsr |= CPSR_T;
1873 } else {
1874 cpsr &= ~CPSR_T;
1875 }
1876
1877 if (ka->sa_flags & TARGET_SA_RESTORER) {
1878 retcode = ka->sa_restorer;
1879 } else {
1880 unsigned int idx = thumb;
1881
1882 if (ka->sa_flags & TARGET_SA_SIGINFO) {
1883 idx += 2;
1884 }
1885
1886 __put_user(retcodes[idx], rc);
1887
1888 retcode = rc_addr + thumb;
1889 }
1890
1891 env->regs[0] = usig;
1892 env->regs[13] = frame_addr;
1893 env->regs[14] = retcode;
1894 env->regs[15] = handler & (thumb ? ~1 : ~3);
1895 cpsr_write(env, cpsr, CPSR_IT | CPSR_T, CPSRWriteByInstr);
1896 }
1897
1898 static abi_ulong *setup_sigframe_v2_vfp(abi_ulong *regspace, CPUARMState *env)
1899 {
1900 int i;
1901 struct target_vfp_sigframe *vfpframe;
1902 vfpframe = (struct target_vfp_sigframe *)regspace;
1903 __put_user(TARGET_VFP_MAGIC, &vfpframe->magic);
1904 __put_user(sizeof(*vfpframe), &vfpframe->size);
1905 for (i = 0; i < 32; i++) {
1906 __put_user(float64_val(env->vfp.regs[i]), &vfpframe->ufp.fpregs[i]);
1907 }
1908 __put_user(vfp_get_fpscr(env), &vfpframe->ufp.fpscr);
1909 __put_user(env->vfp.xregs[ARM_VFP_FPEXC], &vfpframe->ufp_exc.fpexc);
1910 __put_user(env->vfp.xregs[ARM_VFP_FPINST], &vfpframe->ufp_exc.fpinst);
1911 __put_user(env->vfp.xregs[ARM_VFP_FPINST2], &vfpframe->ufp_exc.fpinst2);
1912 return (abi_ulong*)(vfpframe+1);
1913 }
1914
1915 static abi_ulong *setup_sigframe_v2_iwmmxt(abi_ulong *regspace,
1916 CPUARMState *env)
1917 {
1918 int i;
1919 struct target_iwmmxt_sigframe *iwmmxtframe;
1920 iwmmxtframe = (struct target_iwmmxt_sigframe *)regspace;
1921 __put_user(TARGET_IWMMXT_MAGIC, &iwmmxtframe->magic);
1922 __put_user(sizeof(*iwmmxtframe), &iwmmxtframe->size);
1923 for (i = 0; i < 16; i++) {
1924 __put_user(env->iwmmxt.regs[i], &iwmmxtframe->regs[i]);
1925 }
1926 __put_user(env->vfp.xregs[ARM_IWMMXT_wCSSF], &iwmmxtframe->wcssf);
1927 __put_user(env->vfp.xregs[ARM_IWMMXT_wCASF], &iwmmxtframe->wcssf);
1928 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR0], &iwmmxtframe->wcgr0);
1929 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR1], &iwmmxtframe->wcgr1);
1930 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR2], &iwmmxtframe->wcgr2);
1931 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR3], &iwmmxtframe->wcgr3);
1932 return (abi_ulong*)(iwmmxtframe+1);
1933 }
1934
1935 static void setup_sigframe_v2(struct target_ucontext_v2 *uc,
1936 target_sigset_t *set, CPUARMState *env)
1937 {
1938 struct target_sigaltstack stack;
1939 int i;
1940 abi_ulong *regspace;
1941
1942 /* Clear all the bits of the ucontext we don't use. */
1943 memset(uc, 0, offsetof(struct target_ucontext_v2, tuc_mcontext));
1944
1945 memset(&stack, 0, sizeof(stack));
1946 __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp);
1947 __put_user(target_sigaltstack_used.ss_size, &stack.ss_size);
1948 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags);
1949 memcpy(&uc->tuc_stack, &stack, sizeof(stack));
1950
1951 setup_sigcontext(&uc->tuc_mcontext, env, set->sig[0]);
1952 /* Save coprocessor signal frame. */
1953 regspace = uc->tuc_regspace;
1954 if (arm_feature(env, ARM_FEATURE_VFP)) {
1955 regspace = setup_sigframe_v2_vfp(regspace, env);
1956 }
1957 if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
1958 regspace = setup_sigframe_v2_iwmmxt(regspace, env);
1959 }
1960
1961 /* Write terminating magic word */
1962 __put_user(0, regspace);
1963
1964 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1965 __put_user(set->sig[i], &uc->tuc_sigmask.sig[i]);
1966 }
1967 }
1968
1969 /* compare linux/arch/arm/kernel/signal.c:setup_frame() */
1970 static void setup_frame_v1(int usig, struct target_sigaction *ka,
1971 target_sigset_t *set, CPUARMState *regs)
1972 {
1973 struct sigframe_v1 *frame;
1974 abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
1975 int i;
1976
1977 trace_user_setup_frame(regs, frame_addr);
1978 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
1979 goto sigsegv;
1980 }
1981
1982 setup_sigcontext(&frame->sc, regs, set->sig[0]);
1983
1984 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1985 __put_user(set->sig[i], &frame->extramask[i - 1]);
1986 }
1987
1988 setup_return(regs, ka, &frame->retcode, frame_addr, usig,
1989 frame_addr + offsetof(struct sigframe_v1, retcode));
1990
1991 unlock_user_struct(frame, frame_addr, 1);
1992 return;
1993 sigsegv:
1994 force_sigsegv(usig);
1995 }
1996
1997 static void setup_frame_v2(int usig, struct target_sigaction *ka,
1998 target_sigset_t *set, CPUARMState *regs)
1999 {
2000 struct sigframe_v2 *frame;
2001 abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
2002
2003 trace_user_setup_frame(regs, frame_addr);
2004 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
2005 goto sigsegv;
2006 }
2007
2008 setup_sigframe_v2(&frame->uc, set, regs);
2009
2010 setup_return(regs, ka, &frame->retcode, frame_addr, usig,
2011 frame_addr + offsetof(struct sigframe_v2, retcode));
2012
2013 unlock_user_struct(frame, frame_addr, 1);
2014 return;
2015 sigsegv:
2016 force_sigsegv(usig);
2017 }
2018
2019 static void setup_frame(int usig, struct target_sigaction *ka,
2020 target_sigset_t *set, CPUARMState *regs)
2021 {
2022 if (get_osversion() >= 0x020612) {
2023 setup_frame_v2(usig, ka, set, regs);
2024 } else {
2025 setup_frame_v1(usig, ka, set, regs);
2026 }
2027 }
2028
2029 /* compare linux/arch/arm/kernel/signal.c:setup_rt_frame() */
2030 static void setup_rt_frame_v1(int usig, struct target_sigaction *ka,
2031 target_siginfo_t *info,
2032 target_sigset_t *set, CPUARMState *env)
2033 {
2034 struct rt_sigframe_v1 *frame;
2035 abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
2036 struct target_sigaltstack stack;
2037 int i;
2038 abi_ulong info_addr, uc_addr;
2039
2040 trace_user_setup_rt_frame(env, frame_addr);
2041 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
2042 goto sigsegv;
2043 }
2044
2045 info_addr = frame_addr + offsetof(struct rt_sigframe_v1, info);
2046 __put_user(info_addr, &frame->pinfo);
2047 uc_addr = frame_addr + offsetof(struct rt_sigframe_v1, uc);
2048 __put_user(uc_addr, &frame->puc);
2049 tswap_siginfo(&frame->info, info);
2050
2051 /* Clear all the bits of the ucontext we don't use. */
2052 memset(&frame->uc, 0, offsetof(struct target_ucontext_v1, tuc_mcontext));
2053
2054 memset(&stack, 0, sizeof(stack));
2055 __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp);
2056 __put_user(target_sigaltstack_used.ss_size, &stack.ss_size);
2057 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags);
2058 memcpy(&frame->uc.tuc_stack, &stack, sizeof(stack));
2059
2060 setup_sigcontext(&frame->uc.tuc_mcontext, env, set->sig[0]);
2061 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2062 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
2063 }
2064
2065 setup_return(env, ka, &frame->retcode, frame_addr, usig,
2066 frame_addr + offsetof(struct rt_sigframe_v1, retcode));
2067
2068 env->regs[1] = info_addr;
2069 env->regs[2] = uc_addr;
2070
2071 unlock_user_struct(frame, frame_addr, 1);
2072 return;
2073 sigsegv:
2074 force_sigsegv(usig);
2075 }
2076
2077 static void setup_rt_frame_v2(int usig, struct target_sigaction *ka,
2078 target_siginfo_t *info,
2079 target_sigset_t *set, CPUARMState *env)
2080 {
2081 struct rt_sigframe_v2 *frame;
2082 abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
2083 abi_ulong info_addr, uc_addr;
2084
2085 trace_user_setup_rt_frame(env, frame_addr);
2086 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
2087 goto sigsegv;
2088 }
2089
2090 info_addr = frame_addr + offsetof(struct rt_sigframe_v2, info);
2091 uc_addr = frame_addr + offsetof(struct rt_sigframe_v2, uc);
2092 tswap_siginfo(&frame->info, info);
2093
2094 setup_sigframe_v2(&frame->uc, set, env);
2095
2096 setup_return(env, ka, &frame->retcode, frame_addr, usig,
2097 frame_addr + offsetof(struct rt_sigframe_v2, retcode));
2098
2099 env->regs[1] = info_addr;
2100 env->regs[2] = uc_addr;
2101
2102 unlock_user_struct(frame, frame_addr, 1);
2103 return;
2104 sigsegv:
2105 force_sigsegv(usig);
2106 }
2107
2108 static void setup_rt_frame(int usig, struct target_sigaction *ka,
2109 target_siginfo_t *info,
2110 target_sigset_t *set, CPUARMState *env)
2111 {
2112 if (get_osversion() >= 0x020612) {
2113 setup_rt_frame_v2(usig, ka, info, set, env);
2114 } else {
2115 setup_rt_frame_v1(usig, ka, info, set, env);
2116 }
2117 }
2118
2119 static int
2120 restore_sigcontext(CPUARMState *env, struct target_sigcontext *sc)
2121 {
2122 int err = 0;
2123 uint32_t cpsr;
2124
2125 __get_user(env->regs[0], &sc->arm_r0);
2126 __get_user(env->regs[1], &sc->arm_r1);
2127 __get_user(env->regs[2], &sc->arm_r2);
2128 __get_user(env->regs[3], &sc->arm_r3);
2129 __get_user(env->regs[4], &sc->arm_r4);
2130 __get_user(env->regs[5], &sc->arm_r5);
2131 __get_user(env->regs[6], &sc->arm_r6);
2132 __get_user(env->regs[7], &sc->arm_r7);
2133 __get_user(env->regs[8], &sc->arm_r8);
2134 __get_user(env->regs[9], &sc->arm_r9);
2135 __get_user(env->regs[10], &sc->arm_r10);
2136 __get_user(env->regs[11], &sc->arm_fp);
2137 __get_user(env->regs[12], &sc->arm_ip);
2138 __get_user(env->regs[13], &sc->arm_sp);
2139 __get_user(env->regs[14], &sc->arm_lr);
2140 __get_user(env->regs[15], &sc->arm_pc);
2141 #ifdef TARGET_CONFIG_CPU_32
2142 __get_user(cpsr, &sc->arm_cpsr);
2143 cpsr_write(env, cpsr, CPSR_USER | CPSR_EXEC, CPSRWriteByInstr);
2144 #endif
2145
2146 err |= !valid_user_regs(env);
2147
2148 return err;
2149 }
2150
2151 static long do_sigreturn_v1(CPUARMState *env)
2152 {
2153 abi_ulong frame_addr;
2154 struct sigframe_v1 *frame = NULL;
2155 target_sigset_t set;
2156 sigset_t host_set;
2157 int i;
2158
2159 /*
2160 * Since we stacked the signal on a 64-bit boundary,
2161 * then 'sp' should be word aligned here. If it's
2162 * not, then the user is trying to mess with us.
2163 */
2164 frame_addr = env->regs[13];
2165 trace_user_do_sigreturn(env, frame_addr);
2166 if (frame_addr & 7) {
2167 goto badframe;
2168 }
2169
2170 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
2171 goto badframe;
2172 }
2173
2174 __get_user(set.sig[0], &frame->sc.oldmask);
2175 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
2176 __get_user(set.sig[i], &frame->extramask[i - 1]);
2177 }
2178
2179 target_to_host_sigset_internal(&host_set, &set);
2180 set_sigmask(&host_set);
2181
2182 if (restore_sigcontext(env, &frame->sc)) {
2183 goto badframe;
2184 }
2185
2186 #if 0
2187 /* Send SIGTRAP if we're single-stepping */
2188 if (ptrace_cancel_bpt(current))
2189 send_sig(SIGTRAP, current, 1);
2190 #endif
2191 unlock_user_struct(frame, frame_addr, 0);
2192 return -TARGET_QEMU_ESIGRETURN;
2193
2194 badframe:
2195 force_sig(TARGET_SIGSEGV);
2196 return -TARGET_QEMU_ESIGRETURN;
2197 }
2198
2199 static abi_ulong *restore_sigframe_v2_vfp(CPUARMState *env, abi_ulong *regspace)
2200 {
2201 int i;
2202 abi_ulong magic, sz;
2203 uint32_t fpscr, fpexc;
2204 struct target_vfp_sigframe *vfpframe;
2205 vfpframe = (struct target_vfp_sigframe *)regspace;
2206
2207 __get_user(magic, &vfpframe->magic);
2208 __get_user(sz, &vfpframe->size);
2209 if (magic != TARGET_VFP_MAGIC || sz != sizeof(*vfpframe)) {
2210 return 0;
2211 }
2212 for (i = 0; i < 32; i++) {
2213 __get_user(float64_val(env->vfp.regs[i]), &vfpframe->ufp.fpregs[i]);
2214 }
2215 __get_user(fpscr, &vfpframe->ufp.fpscr);
2216 vfp_set_fpscr(env, fpscr);
2217 __get_user(fpexc, &vfpframe->ufp_exc.fpexc);
2218 /* Sanitise FPEXC: ensure VFP is enabled, FPINST2 is invalid
2219 * and the exception flag is cleared
2220 */
2221 fpexc |= (1 << 30);
2222 fpexc &= ~((1 << 31) | (1 << 28));
2223 env->vfp.xregs[ARM_VFP_FPEXC] = fpexc;
2224 __get_user(env->vfp.xregs[ARM_VFP_FPINST], &vfpframe->ufp_exc.fpinst);
2225 __get_user(env->vfp.xregs[ARM_VFP_FPINST2], &vfpframe->ufp_exc.fpinst2);
2226 return (abi_ulong*)(vfpframe + 1);
2227 }
2228
2229 static abi_ulong *restore_sigframe_v2_iwmmxt(CPUARMState *env,
2230 abi_ulong *regspace)
2231 {
2232 int i;
2233 abi_ulong magic, sz;
2234 struct target_iwmmxt_sigframe *iwmmxtframe;
2235 iwmmxtframe = (struct target_iwmmxt_sigframe *)regspace;
2236
2237 __get_user(magic, &iwmmxtframe->magic);
2238 __get_user(sz, &iwmmxtframe->size);
2239 if (magic != TARGET_IWMMXT_MAGIC || sz != sizeof(*iwmmxtframe)) {
2240 return 0;
2241 }
2242 for (i = 0; i < 16; i++) {
2243 __get_user(env->iwmmxt.regs[i], &iwmmxtframe->regs[i]);
2244 }
2245 __get_user(env->vfp.xregs[ARM_IWMMXT_wCSSF], &iwmmxtframe->wcssf);
2246 __get_user(env->vfp.xregs[ARM_IWMMXT_wCASF], &iwmmxtframe->wcssf);
2247 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR0], &iwmmxtframe->wcgr0);
2248 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR1], &iwmmxtframe->wcgr1);
2249 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR2], &iwmmxtframe->wcgr2);
2250 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR3], &iwmmxtframe->wcgr3);
2251 return (abi_ulong*)(iwmmxtframe + 1);
2252 }
2253
2254 static int do_sigframe_return_v2(CPUARMState *env,
2255 target_ulong context_addr,
2256 struct target_ucontext_v2 *uc)
2257 {
2258 sigset_t host_set;
2259 abi_ulong *regspace;
2260
2261 target_to_host_sigset(&host_set, &uc->tuc_sigmask);
2262 set_sigmask(&host_set);
2263
2264 if (restore_sigcontext(env, &uc->tuc_mcontext))
2265 return 1;
2266
2267 /* Restore coprocessor signal frame */
2268 regspace = uc->tuc_regspace;
2269 if (arm_feature(env, ARM_FEATURE_VFP)) {
2270 regspace = restore_sigframe_v2_vfp(env, regspace);
2271 if (!regspace) {
2272 return 1;
2273 }
2274 }
2275 if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
2276 regspace = restore_sigframe_v2_iwmmxt(env, regspace);
2277 if (!regspace) {
2278 return 1;
2279 }
2280 }
2281
2282 if (do_sigaltstack(context_addr
2283 + offsetof(struct target_ucontext_v2, tuc_stack),
2284 0, get_sp_from_cpustate(env)) == -EFAULT) {
2285 return 1;
2286 }
2287
2288 #if 0
2289 /* Send SIGTRAP if we're single-stepping */
2290 if (ptrace_cancel_bpt(current))
2291 send_sig(SIGTRAP, current, 1);
2292 #endif
2293
2294 return 0;
2295 }
2296
2297 static long do_sigreturn_v2(CPUARMState *env)
2298 {
2299 abi_ulong frame_addr;
2300 struct sigframe_v2 *frame = NULL;
2301
2302 /*
2303 * Since we stacked the signal on a 64-bit boundary,
2304 * then 'sp' should be word aligned here. If it's
2305 * not, then the user is trying to mess with us.
2306 */
2307 frame_addr = env->regs[13];
2308 trace_user_do_sigreturn(env, frame_addr);
2309 if (frame_addr & 7) {
2310 goto badframe;
2311 }
2312
2313 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
2314 goto badframe;
2315 }
2316
2317 if (do_sigframe_return_v2(env,
2318 frame_addr
2319 + offsetof(struct sigframe_v2, uc),
2320 &frame->uc)) {
2321 goto badframe;
2322 }
2323
2324 unlock_user_struct(frame, frame_addr, 0);
2325 return -TARGET_QEMU_ESIGRETURN;
2326
2327 badframe:
2328 unlock_user_struct(frame, frame_addr, 0);
2329 force_sig(TARGET_SIGSEGV);
2330 return -TARGET_QEMU_ESIGRETURN;
2331 }
2332
2333 long do_sigreturn(CPUARMState *env)
2334 {
2335 if (get_osversion() >= 0x020612) {
2336 return do_sigreturn_v2(env);
2337 } else {
2338 return do_sigreturn_v1(env);
2339 }
2340 }
2341
2342 static long do_rt_sigreturn_v1(CPUARMState *env)
2343 {
2344 abi_ulong frame_addr;
2345 struct rt_sigframe_v1 *frame = NULL;
2346 sigset_t host_set;
2347
2348 /*
2349 * Since we stacked the signal on a 64-bit boundary,
2350 * then 'sp' should be word aligned here. If it's
2351 * not, then the user is trying to mess with us.
2352 */
2353 frame_addr = env->regs[13];
2354 trace_user_do_rt_sigreturn(env, frame_addr);
2355 if (frame_addr & 7) {
2356 goto badframe;
2357 }
2358
2359 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
2360 goto badframe;
2361 }
2362
2363 target_to_host_sigset(&host_set, &frame->uc.tuc_sigmask);
2364 set_sigmask(&host_set);
2365
2366 if (restore_sigcontext(env, &frame->uc.tuc_mcontext)) {
2367 goto badframe;
2368 }
2369
2370 if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe_v1, uc.tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT)
2371 goto badframe;
2372
2373 #if 0
2374 /* Send SIGTRAP if we're single-stepping */
2375 if (ptrace_cancel_bpt(current))
2376 send_sig(SIGTRAP, current, 1);
2377 #endif
2378 unlock_user_struct(frame, frame_addr, 0);
2379 return -TARGET_QEMU_ESIGRETURN;
2380
2381 badframe:
2382 unlock_user_struct(frame, frame_addr, 0);
2383 force_sig(TARGET_SIGSEGV);
2384 return -TARGET_QEMU_ESIGRETURN;
2385 }
2386
2387 static long do_rt_sigreturn_v2(CPUARMState *env)
2388 {
2389 abi_ulong frame_addr;
2390 struct rt_sigframe_v2 *frame = NULL;
2391
2392 /*
2393 * Since we stacked the signal on a 64-bit boundary,
2394 * then 'sp' should be word aligned here. If it's
2395 * not, then the user is trying to mess with us.
2396 */
2397 frame_addr = env->regs[13];
2398 trace_user_do_rt_sigreturn(env, frame_addr);
2399 if (frame_addr & 7) {
2400 goto badframe;
2401 }
2402
2403 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
2404 goto badframe;
2405 }
2406
2407 if (do_sigframe_return_v2(env,
2408 frame_addr
2409 + offsetof(struct rt_sigframe_v2, uc),
2410 &frame->uc)) {
2411 goto badframe;
2412 }
2413
2414 unlock_user_struct(frame, frame_addr, 0);
2415 return -TARGET_QEMU_ESIGRETURN;
2416
2417 badframe:
2418 unlock_user_struct(frame, frame_addr, 0);
2419 force_sig(TARGET_SIGSEGV);
2420 return -TARGET_QEMU_ESIGRETURN;
2421 }
2422
2423 long do_rt_sigreturn(CPUARMState *env)
2424 {
2425 if (get_osversion() >= 0x020612) {
2426 return do_rt_sigreturn_v2(env);
2427 } else {
2428 return do_rt_sigreturn_v1(env);
2429 }
2430 }
2431
2432 #elif defined(TARGET_SPARC)
2433
2434 #define __SUNOS_MAXWIN 31
2435
2436 /* This is what SunOS does, so shall I. */
2437 struct target_sigcontext {
2438 abi_ulong sigc_onstack; /* state to restore */
2439
2440 abi_ulong sigc_mask; /* sigmask to restore */
2441 abi_ulong sigc_sp; /* stack pointer */
2442 abi_ulong sigc_pc; /* program counter */
2443 abi_ulong sigc_npc; /* next program counter */
2444 abi_ulong sigc_psr; /* for condition codes etc */
2445 abi_ulong sigc_g1; /* User uses these two registers */
2446 abi_ulong sigc_o0; /* within the trampoline code. */
2447
2448 /* Now comes information regarding the users window set
2449 * at the time of the signal.
2450 */
2451 abi_ulong sigc_oswins; /* outstanding windows */
2452
2453 /* stack ptrs for each regwin buf */
2454 char *sigc_spbuf[__SUNOS_MAXWIN];
2455
2456 /* Windows to restore after signal */
2457 struct {
2458 abi_ulong locals[8];
2459 abi_ulong ins[8];
2460 } sigc_wbuf[__SUNOS_MAXWIN];
2461 };
2462 /* A Sparc stack frame */
2463 struct sparc_stackf {
2464 abi_ulong locals[8];
2465 abi_ulong ins[8];
2466 /* It's simpler to treat fp and callers_pc as elements of ins[]
2467 * since we never need to access them ourselves.
2468 */
2469 char *structptr;
2470 abi_ulong xargs[6];
2471 abi_ulong xxargs[1];
2472 };
2473
2474 typedef struct {
2475 struct {
2476 abi_ulong psr;
2477 abi_ulong pc;
2478 abi_ulong npc;
2479 abi_ulong y;
2480 abi_ulong u_regs[16]; /* globals and ins */
2481 } si_regs;
2482 int si_mask;
2483 } __siginfo_t;
2484
2485 typedef struct {
2486 abi_ulong si_float_regs[32];
2487 unsigned long si_fsr;
2488 unsigned long si_fpqdepth;
2489 struct {
2490 unsigned long *insn_addr;
2491 unsigned long insn;
2492 } si_fpqueue [16];
2493 } qemu_siginfo_fpu_t;
2494
2495
2496 struct target_signal_frame {
2497 struct sparc_stackf ss;
2498 __siginfo_t info;
2499 abi_ulong fpu_save;
2500 abi_ulong insns[2] __attribute__ ((aligned (8)));
2501 abi_ulong extramask[TARGET_NSIG_WORDS - 1];
2502 abi_ulong extra_size; /* Should be 0 */
2503 qemu_siginfo_fpu_t fpu_state;
2504 };
2505 struct target_rt_signal_frame {
2506 struct sparc_stackf ss;
2507 siginfo_t info;
2508 abi_ulong regs[20];
2509 sigset_t mask;
2510 abi_ulong fpu_save;
2511 unsigned int insns[2];
2512 stack_t stack;
2513 unsigned int extra_size; /* Should be 0 */
2514 qemu_siginfo_fpu_t fpu_state;
2515 };
2516
2517 #define UREG_O0 16
2518 #define UREG_O6 22
2519 #define UREG_I0 0
2520 #define UREG_I1 1
2521 #define UREG_I2 2
2522 #define UREG_I3 3
2523 #define UREG_I4 4
2524 #define UREG_I5 5
2525 #define UREG_I6 6
2526 #define UREG_I7 7
2527 #define UREG_L0 8
2528 #define UREG_FP UREG_I6
2529 #define UREG_SP UREG_O6
2530
2531 static inline abi_ulong get_sigframe(struct target_sigaction *sa,
2532 CPUSPARCState *env,
2533 unsigned long framesize)
2534 {
2535 abi_ulong sp;
2536
2537 sp = env->regwptr[UREG_FP];
2538
2539 /* This is the X/Open sanctioned signal stack switching. */
2540 if (sa->sa_flags & TARGET_SA_ONSTACK) {
2541 if (!on_sig_stack(sp)
2542 && !((target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size) & 7)) {
2543 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
2544 }
2545 }
2546 return sp - framesize;
2547 }
2548
2549 static int
2550 setup___siginfo(__siginfo_t *si, CPUSPARCState *env, abi_ulong mask)
2551 {
2552 int err = 0, i;
2553
2554 __put_user(env->psr, &si->si_regs.psr);
2555 __put_user(env->pc, &si->si_regs.pc);
2556 __put_user(env->npc, &si->si_regs.npc);
2557 __put_user(env->y, &si->si_regs.y);
2558 for (i=0; i < 8; i++) {
2559 __put_user(env->gregs[i], &si->si_regs.u_regs[i]);
2560 }
2561 for (i=0; i < 8; i++) {
2562 __put_user(env->regwptr[UREG_I0 + i], &si->si_regs.u_regs[i+8]);
2563 }
2564 __put_user(mask, &si->si_mask);
2565 return err;
2566 }
2567
2568 #if 0
2569 static int
2570 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
2571 CPUSPARCState *env, unsigned long mask)
2572 {
2573 int err = 0;
2574
2575 __put_user(mask, &sc->sigc_mask);
2576 __put_user(env->regwptr[UREG_SP], &sc->sigc_sp);
2577 __put_user(env->pc, &sc->sigc_pc);
2578 __put_user(env->npc, &sc->sigc_npc);
2579 __put_user(env->psr, &sc->sigc_psr);
2580 __put_user(env->gregs[1], &sc->sigc_g1);
2581 __put_user(env->regwptr[UREG_O0], &sc->sigc_o0);
2582
2583 return err;
2584 }
2585 #endif
2586 #define NF_ALIGNEDSZ (((sizeof(struct target_signal_frame) + 7) & (~7)))
2587
2588 static void setup_frame(int sig, struct target_sigaction *ka,
2589 target_sigset_t *set, CPUSPARCState *env)
2590 {
2591 abi_ulong sf_addr;
2592 struct target_signal_frame *sf;
2593 int sigframe_size, err, i;
2594
2595 /* 1. Make sure everything is clean */
2596 //synchronize_user_stack();
2597
2598 sigframe_size = NF_ALIGNEDSZ;
2599 sf_addr = get_sigframe(ka, env, sigframe_size);
2600 trace_user_setup_frame(env, sf_addr);
2601
2602 sf = lock_user(VERIFY_WRITE, sf_addr,
2603 sizeof(struct target_signal_frame), 0);
2604 if (!sf) {
2605 goto sigsegv;
2606 }
2607 #if 0
2608 if (invalid_frame_pointer(sf, sigframe_size))
2609 goto sigill_and_return;
2610 #endif
2611 /* 2. Save the current process state */
2612 err = setup___siginfo(&sf->info, env, set->sig[0]);
2613 __put_user(0, &sf->extra_size);
2614
2615 //save_fpu_state(regs, &sf->fpu_state);
2616 //__put_user(&sf->fpu_state, &sf->fpu_save);
2617
2618 __put_user(set->sig[0], &sf->info.si_mask);
2619 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
2620 __put_user(set->sig[i + 1], &sf->extramask[i]);
2621 }
2622
2623 for (i = 0; i < 8; i++) {
2624 __put_user(env->regwptr[i + UREG_L0], &sf->ss.locals[i]);
2625 }
2626 for (i = 0; i < 8; i++) {
2627 __put_user(env->regwptr[i + UREG_I0], &sf->ss.ins[i]);
2628 }
2629 if (err)
2630 goto sigsegv;
2631
2632 /* 3. signal handler back-trampoline and parameters */
2633 env->regwptr[UREG_FP] = sf_addr;
2634 env->regwptr[UREG_I0] = sig;
2635 env->regwptr[UREG_I1] = sf_addr +
2636 offsetof(struct target_signal_frame, info);
2637 env->regwptr[UREG_I2] = sf_addr +
2638 offsetof(struct target_signal_frame, info);
2639
2640 /* 4. signal handler */
2641 env->pc = ka->_sa_handler;
2642 env->npc = (env->pc + 4);
2643 /* 5. return to kernel instructions */
2644 if (ka->sa_restorer) {
2645 env->regwptr[UREG_I7] = ka->sa_restorer;
2646 } else {
2647 uint32_t val32;
2648
2649 env->regwptr[UREG_I7] = sf_addr +
2650 offsetof(struct target_signal_frame, insns) - 2 * 4;
2651
2652 /* mov __NR_sigreturn, %g1 */
2653 val32 = 0x821020d8;
2654 __put_user(val32, &sf->insns[0]);
2655
2656 /* t 0x10 */
2657 val32 = 0x91d02010;
2658 __put_user(val32, &sf->insns[1]);
2659 if (err)
2660 goto sigsegv;
2661
2662 /* Flush instruction space. */
2663 // flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
2664 // tb_flush(env);
2665 }
2666 unlock_user(sf, sf_addr, sizeof(struct target_signal_frame));
2667 return;
2668 #if 0
2669 sigill_and_return:
2670 force_sig(TARGET_SIGILL);
2671 #endif
2672 sigsegv:
2673 unlock_user(sf, sf_addr, sizeof(struct target_signal_frame));
2674 force_sigsegv(sig);
2675 }
2676
2677 static void setup_rt_frame(int sig, struct target_sigaction *ka,
2678 target_siginfo_t *info,
2679 target_sigset_t *set, CPUSPARCState *env)
2680 {
2681 fprintf(stderr, "setup_rt_frame: not implemented\n");
2682 }
2683
2684 long do_sigreturn(CPUSPARCState *env)
2685 {
2686 abi_ulong sf_addr;
2687 struct target_signal_frame *sf;
2688 uint32_t up_psr, pc, npc;
2689 target_sigset_t set;
2690 sigset_t host_set;
2691 int err=0, i;
2692
2693 sf_addr = env->regwptr[UREG_FP];
2694 trace_user_do_sigreturn(env, sf_addr);
2695 if (!lock_user_struct(VERIFY_READ, sf, sf_addr, 1)) {
2696 goto segv_and_exit;
2697 }
2698
2699 /* 1. Make sure we are not getting garbage from the user */
2700
2701 if (sf_addr & 3)
2702 goto segv_and_exit;
2703
2704 __get_user(pc, &sf->info.si_regs.pc);
2705 __get_user(npc, &sf->info.si_regs.npc);
2706
2707 if ((pc | npc) & 3) {
2708 goto segv_and_exit;
2709 }
2710
2711 /* 2. Restore the state */
2712 __get_user(up_psr, &sf->info.si_regs.psr);
2713
2714 /* User can only change condition codes and FPU enabling in %psr. */
2715 env->psr = (up_psr & (PSR_ICC /* | PSR_EF */))
2716 | (env->psr & ~(PSR_ICC /* | PSR_EF */));
2717
2718 env->pc = pc;
2719 env->npc = npc;
2720 __get_user(env->y, &sf->info.si_regs.y);
2721 for (i=0; i < 8; i++) {
2722 __get_user(env->gregs[i], &sf->info.si_regs.u_regs[i]);
2723 }
2724 for (i=0; i < 8; i++) {
2725 __get_user(env->regwptr[i + UREG_I0], &sf->info.si_regs.u_regs[i+8]);
2726 }
2727
2728 /* FIXME: implement FPU save/restore:
2729 * __get_user(fpu_save, &sf->fpu_save);
2730 * if (fpu_save)
2731 * err |= restore_fpu_state(env, fpu_save);
2732 */
2733
2734 /* This is pretty much atomic, no amount locking would prevent
2735 * the races which exist anyways.
2736 */
2737 __get_user(set.sig[0], &sf->info.si_mask);
2738 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
2739 __get_user(set.sig[i], &sf->extramask[i - 1]);
2740 }
2741
2742 target_to_host_sigset_internal(&host_set, &set);
2743 set_sigmask(&host_set);
2744
2745 if (err) {
2746 goto segv_and_exit;
2747 }
2748 unlock_user_struct(sf, sf_addr, 0);
2749 return -TARGET_QEMU_ESIGRETURN;
2750
2751 segv_and_exit:
2752 unlock_user_struct(sf, sf_addr, 0);
2753 force_sig(TARGET_SIGSEGV);
2754 return -TARGET_QEMU_ESIGRETURN;
2755 }
2756
2757 long do_rt_sigreturn(CPUSPARCState *env)
2758 {
2759 trace_user_do_rt_sigreturn(env, 0);
2760 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
2761 return -TARGET_ENOSYS;
2762 }
2763
2764 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
2765 #define MC_TSTATE 0
2766 #define MC_PC 1
2767 #define MC_NPC 2
2768 #define MC_Y 3
2769 #define MC_G1 4
2770 #define MC_G2 5
2771 #define MC_G3 6
2772 #define MC_G4 7
2773 #define MC_G5 8
2774 #define MC_G6 9
2775 #define MC_G7 10
2776 #define MC_O0 11
2777 #define MC_O1 12
2778 #define MC_O2 13
2779 #define MC_O3 14
2780 #define MC_O4 15
2781 #define MC_O5 16
2782 #define MC_O6 17
2783 #define MC_O7 18
2784 #define MC_NGREG 19
2785
2786 typedef abi_ulong target_mc_greg_t;
2787 typedef target_mc_greg_t target_mc_gregset_t[MC_NGREG];
2788
2789 struct target_mc_fq {
2790 abi_ulong *mcfq_addr;
2791 uint32_t mcfq_insn;
2792 };
2793
2794 struct target_mc_fpu {
2795 union {
2796 uint32_t sregs[32];
2797 uint64_t dregs[32];
2798 //uint128_t qregs[16];
2799 } mcfpu_fregs;
2800 abi_ulong mcfpu_fsr;
2801 abi_ulong mcfpu_fprs;
2802 abi_ulong mcfpu_gsr;
2803 struct target_mc_fq *mcfpu_fq;
2804 unsigned char mcfpu_qcnt;
2805 unsigned char mcfpu_qentsz;
2806 unsigned char mcfpu_enab;
2807 };
2808 typedef struct target_mc_fpu target_mc_fpu_t;
2809
2810 typedef struct {
2811 target_mc_gregset_t mc_gregs;
2812 target_mc_greg_t mc_fp;
2813 target_mc_greg_t mc_i7;
2814 target_mc_fpu_t mc_fpregs;
2815 } target_mcontext_t;
2816
2817 struct target_ucontext {
2818 struct target_ucontext *tuc_link;
2819 abi_ulong tuc_flags;
2820 target_sigset_t tuc_sigmask;
2821 target_mcontext_t tuc_mcontext;
2822 };
2823
2824 /* A V9 register window */
2825 struct target_reg_window {
2826 abi_ulong locals[8];
2827 abi_ulong ins[8];
2828 };
2829
2830 #define TARGET_STACK_BIAS 2047
2831
2832 /* {set, get}context() needed for 64-bit SparcLinux userland. */
2833 void sparc64_set_context(CPUSPARCState *env)
2834 {
2835 abi_ulong ucp_addr;
2836 struct target_ucontext *ucp;
2837 target_mc_gregset_t *grp;
2838 abi_ulong pc, npc, tstate;
2839 abi_ulong fp, i7, w_addr;
2840 unsigned int i;
2841
2842 ucp_addr = env->regwptr[UREG_I0];
2843 if (!lock_user_struct(VERIFY_READ, ucp, ucp_addr, 1)) {
2844 goto do_sigsegv;
2845 }
2846 grp = &ucp->tuc_mcontext.mc_gregs;
2847 __get_user(pc, &((*grp)[MC_PC]));
2848 __get_user(npc, &((*grp)[MC_NPC]));
2849 if ((pc | npc) & 3) {
2850 goto do_sigsegv;
2851 }
2852 if (env->regwptr[UREG_I1]) {
2853 target_sigset_t target_set;
2854 sigset_t set;
2855
2856 if (TARGET_NSIG_WORDS == 1) {
2857 __get_user(target_set.sig[0], &ucp->tuc_sigmask.sig[0]);
2858 } else {
2859 abi_ulong *src, *dst;
2860 src = ucp->tuc_sigmask.sig;
2861 dst = target_set.sig;
2862 for (i = 0; i < TARGET_NSIG_WORDS; i++, dst++, src++) {
2863 __get_user(*dst, src);
2864 }
2865 }
2866 target_to_host_sigset_internal(&set, &target_set);
2867 set_sigmask(&set);
2868 }
2869 env->pc = pc;
2870 env->npc = npc;
2871 __get_user(env->y, &((*grp)[MC_Y]));
2872 __get_user(tstate, &((*grp)[MC_TSTATE]));
2873 env->asi = (tstate >> 24) & 0xff;
2874 cpu_put_ccr(env, tstate >> 32);
2875 cpu_put_cwp64(env, tstate & 0x1f);
2876 __get_user(env->gregs[1], (&(*grp)[MC_G1]));
2877 __get_user(env->gregs[2], (&(*grp)[MC_G2]));
2878 __get_user(env->gregs[3], (&(*grp)[MC_G3]));
2879 __get_user(env->gregs[4], (&(*grp)[MC_G4]));
2880 __get_user(env->gregs[5], (&(*grp)[MC_G5]));
2881 __get_user(env->gregs[6], (&(*grp)[MC_G6]));
2882 __get_user(env->gregs[7], (&(*grp)[MC_G7]));
2883 __get_user(env->regwptr[UREG_I0], (&(*grp)[MC_O0]));
2884 __get_user(env->regwptr[UREG_I1], (&(*grp)[MC_O1]));
2885 __get_user(env->regwptr[UREG_I2], (&(*grp)[MC_O2]));
2886 __get_user(env->regwptr[UREG_I3], (&(*grp)[MC_O3]));
2887 __get_user(env->regwptr[UREG_I4], (&(*grp)[MC_O4]));
2888 __get_user(env->regwptr[UREG_I5], (&(*grp)[MC_O5]));
2889 __get_user(env->regwptr[UREG_I6], (&(*grp)[MC_O6]));
2890 __get_user(env->regwptr[UREG_I7], (&(*grp)[MC_O7]));
2891
2892 __get_user(fp, &(ucp->tuc_mcontext.mc_fp));
2893 __get_user(i7, &(ucp->tuc_mcontext.mc_i7));
2894
2895 w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
2896 if (put_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]),
2897 abi_ulong) != 0) {
2898 goto do_sigsegv;
2899 }
2900 if (put_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]),
2901 abi_ulong) != 0) {
2902 goto do_sigsegv;
2903 }
2904 /* FIXME this does not match how the kernel handles the FPU in
2905 * its sparc64_set_context implementation. In particular the FPU
2906 * is only restored if fenab is non-zero in:
2907 * __get_user(fenab, &(ucp->tuc_mcontext.mc_fpregs.mcfpu_enab));
2908 */
2909 __get_user(env->fprs, &(ucp->tuc_mcontext.mc_fpregs.mcfpu_fprs));
2910 {
2911 uint32_t *src = ucp->tuc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2912 for (i = 0; i < 64; i++, src++) {
2913 if (i & 1) {
2914 __get_user(env->fpr[i/2].l.lower, src);
2915 } else {
2916 __get_user(env->fpr[i/2].l.upper, src);
2917 }
2918 }
2919 }
2920 __get_user(env->fsr,
2921 &(ucp->tuc_mcontext.mc_fpregs.mcfpu_fsr));
2922 __get_user(env->gsr,
2923 &(ucp->tuc_mcontext.mc_fpregs.mcfpu_gsr));
2924 unlock_user_struct(ucp, ucp_addr, 0);
2925 return;
2926 do_sigsegv:
2927 unlock_user_struct(ucp, ucp_addr, 0);
2928 force_sig(TARGET_SIGSEGV);
2929 }
2930
2931 void sparc64_get_context(CPUSPARCState *env)
2932 {
2933 abi_ulong ucp_addr;
2934 struct target_ucontext *ucp;
2935 target_mc_gregset_t *grp;
2936 target_mcontext_t *mcp;
2937 abi_ulong fp, i7, w_addr;
2938 int err;
2939 unsigned int i;
2940 target_sigset_t target_set;
2941 sigset_t set;
2942
2943 ucp_addr = env->regwptr[UREG_I0];
2944 if (!lock_user_struct(VERIFY_WRITE, ucp, ucp_addr, 0)) {
2945 goto do_sigsegv;
2946 }
2947
2948 mcp = &ucp->tuc_mcontext;
2949 grp = &mcp->mc_gregs;
2950
2951 /* Skip over the trap instruction, first. */
2952 env->pc = env->npc;
2953 env->npc += 4;
2954
2955 /* If we're only reading the signal mask then do_sigprocmask()
2956 * is guaranteed not to fail, which is important because we don't
2957 * have any way to signal a failure or restart this operation since
2958 * this is not a normal syscall.
2959 */
2960 err = do_sigprocmask(0, NULL, &set);
2961 assert(err == 0);
2962 host_to_target_sigset_internal(&target_set, &set);
2963 if (TARGET_NSIG_WORDS == 1) {
2964 __put_user(target_set.sig[0],
2965 (abi_ulong *)&ucp->tuc_sigmask);
2966 } else {
2967 abi_ulong *src, *dst;
2968 src = target_set.sig;
2969 dst = ucp->tuc_sigmask.sig;
2970 for (i = 0; i < TARGET_NSIG_WORDS; i++, dst++, src++) {
2971 __put_user(*src, dst);
2972 }
2973 if (err)
2974 goto do_sigsegv;
2975 }
2976
2977 /* XXX: tstate must be saved properly */
2978 // __put_user(env->tstate, &((*grp)[MC_TSTATE]));
2979 __put_user(env->pc, &((*grp)[MC_PC]));
2980 __put_user(env->npc, &((*grp)[MC_NPC]));
2981 __put_user(env->y, &((*grp)[MC_Y]));
2982 __put_user(env->gregs[1], &((*grp)[MC_G1]));
2983 __put_user(env->gregs[2], &((*grp)[MC_G2]));
2984 __put_user(env->gregs[3], &((*grp)[MC_G3]));
2985 __put_user(env->gregs[4], &((*grp)[MC_G4]));
2986 __put_user(env->gregs[5], &((*grp)[MC_G5]));
2987 __put_user(env->gregs[6], &((*grp)[MC_G6]));
2988 __put_user(env->gregs[7], &((*grp)[MC_G7]));
2989 __put_user(env->regwptr[UREG_I0], &((*grp)[MC_O0]));
2990 __put_user(env->regwptr[UREG_I1], &((*grp)[MC_O1]));
2991 __put_user(env->regwptr[UREG_I2], &((*grp)[MC_O2]));
2992 __put_user(env->regwptr[UREG_I3], &((*grp)[MC_O3]));
2993 __put_user(env->regwptr[UREG_I4], &((*grp)[MC_O4]));
2994 __put_user(env->regwptr[UREG_I5], &((*grp)[MC_O5]));
2995 __put_user(env->regwptr[UREG_I6], &((*grp)[MC_O6]));
2996 __put_user(env->regwptr[UREG_I7], &((*grp)[MC_O7]));
2997
2998 w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
2999 fp = i7 = 0;
3000 if (get_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]),
3001 abi_ulong) != 0) {
3002 goto do_sigsegv;
3003 }
3004 if (get_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]),
3005 abi_ulong) != 0) {
3006 goto do_sigsegv;
3007 }
3008 __put_user(fp, &(mcp->mc_fp));
3009 __put_user(i7, &(mcp->mc_i7));
3010
3011 {
3012 uint32_t *dst = ucp->tuc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
3013 for (i = 0; i < 64; i++, dst++) {
3014 if (i & 1) {
3015 __put_user(env->fpr[i/2].l.lower, dst);
3016 } else {
3017 __put_user(env->fpr[i/2].l.upper, dst);
3018 }
3019 }
3020 }
3021 __put_user(env->fsr, &(mcp->mc_fpregs.mcfpu_fsr));
3022 __put_user(env->gsr, &(mcp->mc_fpregs.mcfpu_gsr));
3023 __put_user(env->fprs, &(mcp->mc_fpregs.mcfpu_fprs));
3024
3025 if (err)
3026 goto do_sigsegv;
3027 unlock_user_struct(ucp, ucp_addr, 1);
3028 return;
3029 do_sigsegv:
3030 unlock_user_struct(ucp, ucp_addr, 1);
3031 force_sig(TARGET_SIGSEGV);
3032 }
3033 #endif
3034 #elif defined(TARGET_MIPS) || defined(TARGET_MIPS64)
3035
3036 # if defined(TARGET_ABI_MIPSO32)
3037 struct target_sigcontext {
3038 uint32_t sc_regmask; /* Unused */
3039 uint32_t sc_status;
3040 uint64_t sc_pc;
3041 uint64_t sc_regs[32];
3042 uint64_t sc_fpregs[32];
3043 uint32_t sc_ownedfp; /* Unused */
3044 uint32_t sc_fpc_csr;
3045 uint32_t sc_fpc_eir; /* Unused */
3046 uint32_t sc_used_math;
3047 uint32_t sc_dsp; /* dsp status, was sc_ssflags */
3048 uint32_t pad0;
3049 uint64_t sc_mdhi;
3050 uint64_t sc_mdlo;
3051 target_ulong sc_hi1; /* Was sc_cause */
3052 target_ulong sc_lo1; /* Was sc_badvaddr */
3053 target_ulong sc_hi2; /* Was sc_sigset[4] */
3054 target_ulong sc_lo2;
3055 target_ulong sc_hi3;
3056 target_ulong sc_lo3;
3057 };
3058 # else /* N32 || N64 */
3059 struct target_sigcontext {
3060 uint64_t sc_regs[32];
3061 uint64_t sc_fpregs[32];
3062 uint64_t sc_mdhi;
3063 uint64_t sc_hi1;
3064 uint64_t sc_hi2;
3065 uint64_t sc_hi3;
3066 uint64_t sc_mdlo;
3067 uint64_t sc_lo1;
3068 uint64_t sc_lo2;
3069 uint64_t sc_lo3;
3070 uint64_t sc_pc;
3071 uint32_t sc_fpc_csr;
3072 uint32_t sc_used_math;
3073 uint32_t sc_dsp;
3074 uint32_t sc_reserved;
3075 };
3076 # endif /* O32 */
3077
3078 struct sigframe {
3079 uint32_t sf_ass[4]; /* argument save space for o32 */
3080 uint32_t sf_code[2]; /* signal trampoline */
3081 struct target_sigcontext sf_sc;
3082 target_sigset_t sf_mask;
3083 };
3084
3085 struct target_ucontext {
3086 target_ulong tuc_flags;
3087 target_ulong tuc_link;
3088 target_stack_t tuc_stack;
3089 target_ulong pad0;
3090 struct target_sigcontext tuc_mcontext;
3091 target_sigset_t tuc_sigmask;
3092 };
3093
3094 struct target_rt_sigframe {
3095 uint32_t rs_ass[4]; /* argument save space for o32 */
3096 uint32_t rs_code[2]; /* signal trampoline */
3097 struct target_siginfo rs_info;
3098 struct target_ucontext rs_uc;
3099 };
3100
3101 /* Install trampoline to jump back from signal handler */
3102 static inline int install_sigtramp(unsigned int *tramp, unsigned int syscall)
3103 {
3104 int err = 0;
3105
3106 /*
3107 * Set up the return code ...
3108 *
3109 * li v0, __NR__foo_sigreturn
3110 * syscall
3111 */
3112
3113 __put_user(0x24020000 + syscall, tramp + 0);
3114 __put_user(0x0000000c , tramp + 1);
3115 return err;
3116 }
3117
3118 static inline void setup_sigcontext(CPUMIPSState *regs,
3119 struct target_sigcontext *sc)
3120 {
3121 int i;
3122
3123 __put_user(exception_resume_pc(regs), &sc->sc_pc);
3124 regs->hflags &= ~MIPS_HFLAG_BMASK;
3125
3126 __put_user(0, &sc->sc_regs[0]);
3127 for (i = 1; i < 32; ++i) {
3128 __put_user(regs->active_tc.gpr[i], &sc->sc_regs[i]);
3129 }
3130
3131 __put_user(regs->active_tc.HI[0], &sc->sc_mdhi);
3132 __put_user(regs->active_tc.LO[0], &sc->sc_mdlo);
3133
3134 /* Rather than checking for dsp existence, always copy. The storage
3135 would just be garbage otherwise. */
3136 __put_user(regs->active_tc.HI[1], &sc->sc_hi1);
3137 __put_user(regs->active_tc.HI[2], &sc->sc_hi2);
3138 __put_user(regs->active_tc.HI[3], &sc->sc_hi3);
3139 __put_user(regs->active_tc.LO[1], &sc->sc_lo1);
3140 __put_user(regs->active_tc.LO[2], &sc->sc_lo2);
3141 __put_user(regs->active_tc.LO[3], &sc->sc_lo3);
3142 {
3143 uint32_t dsp = cpu_rddsp(0x3ff, regs);
3144 __put_user(dsp, &sc->sc_dsp);
3145 }
3146
3147 __put_user(1, &sc->sc_used_math);
3148
3149 for (i = 0; i < 32; ++i) {
3150 __put_user(regs->active_fpu.fpr[i].d, &sc->sc_fpregs[i]);
3151 }
3152 }
3153
3154 static inline void
3155 restore_sigcontext(CPUMIPSState *regs, struct target_sigcontext *sc)
3156 {
3157 int i;
3158
3159 __get_user(regs->CP0_EPC, &sc->sc_pc);
3160
3161 __get_user(regs->active_tc.HI[0], &sc->sc_mdhi);
3162 __get_user(regs->active_tc.LO[0], &sc->sc_mdlo);
3163
3164 for (i = 1; i < 32; ++i) {
3165 __get_user(regs->active_tc.gpr[i], &sc->sc_regs[i]);
3166 }
3167
3168 __get_user(regs->active_tc.HI[1], &sc->sc_hi1);
3169 __get_user(regs->active_tc.HI[2], &sc->sc_hi2);
3170 __get_user(regs->active_tc.HI[3], &sc->sc_hi3);
3171 __get_user(regs->active_tc.LO[1], &sc->sc_lo1);
3172 __get_user(regs->active_tc.LO[2], &sc->sc_lo2);
3173 __get_user(regs->active_tc.LO[3], &sc->sc_lo3);
3174 {
3175 uint32_t dsp;
3176 __get_user(dsp, &sc->sc_dsp);
3177 cpu_wrdsp(dsp, 0x3ff, regs);
3178 }
3179
3180 for (i = 0; i < 32; ++i) {
3181 __get_user(regs->active_fpu.fpr[i].d, &sc->sc_fpregs[i]);
3182 }
3183 }
3184
3185 /*
3186 * Determine which stack to use..
3187 */
3188 static inline abi_ulong
3189 get_sigframe(struct target_sigaction *ka, CPUMIPSState *regs, size_t frame_size)
3190 {
3191 unsigned long sp;
3192
3193 /* Default to using normal stack */
3194 sp = regs->active_tc.gpr[29];
3195
3196 /*
3197 * FPU emulator may have its own trampoline active just
3198 * above the user stack, 16-bytes before the next lowest
3199 * 16 byte boundary. Try to avoid trashing it.
3200 */
3201 sp -= 32;
3202
3203 /* This is the X/Open sanctioned signal stack switching. */
3204 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) {
3205 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
3206 }
3207
3208 return (sp - frame_size) & ~7;
3209 }
3210
3211 static void mips_set_hflags_isa_mode_from_pc(CPUMIPSState *env)
3212 {
3213 if (env->insn_flags & (ASE_MIPS16 | ASE_MICROMIPS)) {
3214 env->hflags &= ~MIPS_HFLAG_M16;
3215 env->hflags |= (env->active_tc.PC & 1) << MIPS_HFLAG_M16_SHIFT;
3216 env->active_tc.PC &= ~(target_ulong) 1;
3217 }
3218 }
3219
3220 # if defined(TARGET_ABI_MIPSO32)
3221 /* compare linux/arch/mips/kernel/signal.c:setup_frame() */
3222 static void setup_frame(int sig, struct target_sigaction * ka,
3223 target_sigset_t *set, CPUMIPSState *regs)
3224 {
3225 struct sigframe *frame;
3226 abi_ulong frame_addr;
3227 int i;
3228
3229 frame_addr = get_sigframe(ka, regs, sizeof(*frame));
3230 trace_user_setup_frame(regs, frame_addr);
3231 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
3232 goto give_sigsegv;
3233 }
3234
3235 install_sigtramp(frame->sf_code, TARGET_NR_sigreturn);
3236
3237 setup_sigcontext(regs, &frame->sf_sc);
3238
3239 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
3240 __put_user(set->sig[i], &frame->sf_mask.sig[i]);
3241 }
3242
3243 /*
3244 * Arguments to signal handler:
3245 *
3246 * a0 = signal number
3247 * a1 = 0 (should be cause)
3248 * a2 = pointer to struct sigcontext
3249 *
3250 * $25 and PC point to the signal handler, $29 points to the
3251 * struct sigframe.
3252 */
3253 regs->active_tc.gpr[ 4] = sig;
3254 regs->active_tc.gpr[ 5] = 0;
3255 regs->active_tc.gpr[ 6] = frame_addr + offsetof(struct sigframe, sf_sc);
3256 regs->active_tc.gpr[29] = frame_addr;
3257 regs->active_tc.gpr[31] = frame_addr + offsetof(struct sigframe, sf_code);
3258 /* The original kernel code sets CP0_EPC to the handler
3259 * since it returns to userland using eret
3260 * we cannot do this here, and we must set PC directly */
3261 regs->active_tc.PC = regs->active_tc.gpr[25] = ka->_sa_handler;
3262 mips_set_hflags_isa_mode_from_pc(regs);
3263 unlock_user_struct(frame, frame_addr, 1);
3264 return;
3265
3266 give_sigsegv:
3267 force_sigsegv(sig);
3268 }
3269
3270 long do_sigreturn(CPUMIPSState *regs)
3271 {
3272 struct sigframe *frame;
3273 abi_ulong frame_addr;
3274 sigset_t blocked;
3275 target_sigset_t target_set;
3276 int i;
3277
3278 frame_addr = regs->active_tc.gpr[29];
3279 trace_user_do_sigreturn(regs, frame_addr);
3280 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
3281 goto badframe;
3282
3283 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
3284 __get_user(target_set.sig[i], &frame->sf_mask.sig[i]);
3285 }
3286
3287 target_to_host_sigset_internal(&blocked, &target_set);
3288 set_sigmask(&blocked);
3289
3290 restore_sigcontext(regs, &frame->sf_sc);
3291
3292 #if 0
3293 /*
3294 * Don't let your children do this ...
3295 */
3296 __asm__ __volatile__(
3297 "move\t$29, %0\n\t"
3298 "j\tsyscall_exit"
3299 :/* no outputs */
3300 :"r" (&regs));
3301 /* Unreached */
3302 #endif
3303
3304 regs->active_tc.PC = regs->CP0_EPC;
3305 mips_set_hflags_isa_mode_from_pc(regs);
3306 /* I am not sure this is right, but it seems to work
3307 * maybe a problem with nested signals ? */
3308 regs->CP0_EPC = 0;
3309 return -TARGET_QEMU_ESIGRETURN;
3310
3311 badframe:
3312 force_sig(TARGET_SIGSEGV);
3313 return -TARGET_QEMU_ESIGRETURN;
3314 }
3315 # endif /* O32 */
3316
3317 static void setup_rt_frame(int sig, struct target_sigaction *ka,
3318 target_siginfo_t *info,
3319 target_sigset_t *set, CPUMIPSState *env)
3320 {
3321 struct target_rt_sigframe *frame;
3322 abi_ulong frame_addr;
3323 int i;
3324
3325 frame_addr = get_sigframe(ka, env, sizeof(*frame));
3326 trace_user_setup_rt_frame(env, frame_addr);
3327 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
3328 goto give_sigsegv;
3329 }
3330
3331 install_sigtramp(frame->rs_code, TARGET_NR_rt_sigreturn);
3332
3333 tswap_siginfo(&frame->rs_info, info);
3334
3335 __put_user(0, &frame->rs_uc.tuc_flags);
3336 __put_user(0, &frame->rs_uc.tuc_link);
3337 __put_user(target_sigaltstack_used.ss_sp, &frame->rs_uc.tuc_stack.ss_sp);
3338 __put_user(target_sigaltstack_used.ss_size, &frame->rs_uc.tuc_stack.ss_size);
3339 __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
3340 &frame->rs_uc.tuc_stack.ss_flags);
3341
3342 setup_sigcontext(env, &frame->rs_uc.tuc_mcontext);
3343
3344 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
3345 __put_user(set->sig[i], &frame->rs_uc.tuc_sigmask.sig[i]);
3346 }
3347
3348 /*
3349 * Arguments to signal handler:
3350 *
3351 * a0 = signal number
3352 * a1 = pointer to siginfo_t
3353 * a2 = pointer to ucontext_t
3354 *
3355 * $25 and PC point to the signal handler, $29 points to the
3356 * struct sigframe.
3357 */
3358 env->active_tc.gpr[ 4] = sig;
3359 env->active_tc.gpr[ 5] = frame_addr
3360 + offsetof(struct target_rt_sigframe, rs_info);
3361 env->active_tc.gpr[ 6] = frame_addr
3362 + offsetof(struct target_rt_sigframe, rs_uc);
3363 env->active_tc.gpr[29] = frame_addr;
3364 env->active_tc.gpr[31] = frame_addr
3365 + offsetof(struct target_rt_sigframe, rs_code);
3366 /* The original kernel code sets CP0_EPC to the handler
3367 * since it returns to userland using eret
3368 * we cannot do this here, and we must set PC directly */
3369 env->active_tc.PC = env->active_tc.gpr[25] = ka->_sa_handler;
3370 mips_set_hflags_isa_mode_from_pc(env);
3371 unlock_user_struct(frame, frame_addr, 1);
3372 return;
3373
3374 give_sigsegv:
3375 unlock_user_struct(frame, frame_addr, 1);
3376 force_sigsegv(sig);
3377 }
3378
3379 long do_rt_sigreturn(CPUMIPSState *env)
3380 {
3381 struct target_rt_sigframe *frame;
3382 abi_ulong frame_addr;
3383 sigset_t blocked;
3384
3385 frame_addr = env->active_tc.gpr[29];
3386 trace_user_do_rt_sigreturn(env, frame_addr);
3387 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
3388 goto badframe;
3389 }
3390
3391 target_to_host_sigset(&blocked, &frame->rs_uc.tuc_sigmask);
3392 set_sigmask(&blocked);
3393
3394 restore_sigcontext(env, &frame->rs_uc.tuc_mcontext);
3395
3396 if (do_sigaltstack(frame_addr +
3397 offsetof(struct target_rt_sigframe, rs_uc.tuc_stack),
3398 0, get_sp_from_cpustate(env)) == -EFAULT)
3399 goto badframe;
3400
3401 env->active_tc.PC = env->CP0_EPC;
3402 mips_set_hflags_isa_mode_from_pc(env);
3403 /* I am not sure this is right, but it seems to work
3404 * maybe a problem with nested signals ? */
3405 env->CP0_EPC = 0;
3406 return -TARGET_QEMU_ESIGRETURN;
3407
3408 badframe:
3409 force_sig(TARGET_SIGSEGV);
3410 return -TARGET_QEMU_ESIGRETURN;
3411 }
3412
3413 #elif defined(TARGET_SH4)
3414
3415 /*
3416 * code and data structures from linux kernel:
3417 * include/asm-sh/sigcontext.h
3418 * arch/sh/kernel/signal.c
3419 */
3420
3421 struct target_sigcontext {
3422 target_ulong oldmask;
3423
3424 /* CPU registers */
3425 target_ulong sc_gregs[16];
3426 target_ulong sc_pc;
3427 target_ulong sc_pr;
3428 target_ulong sc_sr;
3429 target_ulong sc_gbr;
3430 target_ulong sc_mach;
3431 target_ulong sc_macl;
3432
3433 /* FPU registers */
3434 target_ulong sc_fpregs[16];
3435 target_ulong sc_xfpregs[16];
3436 unsigned int sc_fpscr;
3437 unsigned int sc_fpul;
3438 unsigned int sc_ownedfp;
3439 };
3440
3441 struct target_sigframe
3442 {
3443 struct target_sigcontext sc;
3444 target_ulong extramask[TARGET_NSIG_WORDS-1];
3445 uint16_t retcode[3];
3446 };
3447
3448
3449 struct target_ucontext {
3450 target_ulong tuc_flags;
3451 struct target_ucontext *tuc_link;
3452 target_stack_t tuc_stack;
3453 struct target_sigcontext tuc_mcontext;
3454 target_sigset_t tuc_sigmask; /* mask last for extensibility */
3455 };
3456
3457 struct target_rt_sigframe
3458 {
3459 struct target_siginfo info;
3460 struct target_ucontext uc;
3461 uint16_t retcode[3];
3462 };
3463
3464
3465 #define MOVW(n) (0x9300|((n)-2)) /* Move mem word at PC+n to R3 */
3466 #define TRAP_NOARG 0xc310 /* Syscall w/no args (NR in R3) SH3/4 */
3467
3468 static abi_ulong get_sigframe(struct target_sigaction *ka,
3469 unsigned long sp, size_t frame_size)
3470 {
3471 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags(sp) == 0)) {
3472 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
3473 }
3474
3475 return (sp - frame_size) & -8ul;
3476 }
3477
3478 /* Notice when we're in the middle of a gUSA region and reset.
3479 Note that this will only occur for !parallel_cpus, as we will
3480 translate such sequences differently in a parallel context. */
3481 static void unwind_gusa(CPUSH4State *regs)
3482 {
3483 /* If the stack pointer is sufficiently negative, and we haven't
3484 completed the sequence, then reset to the entry to the region. */
3485 /* ??? The SH4 kernel checks for and address above 0xC0000000.
3486 However, the page mappings in qemu linux-user aren't as restricted
3487 and we wind up with the normal stack mapped above 0xF0000000.
3488 That said, there is no reason why the kernel should be allowing
3489 a gUSA region that spans 1GB. Use a tighter check here, for what
3490 can actually be enabled by the immediate move. */
3491 if (regs->gregs[15] >= -128u && regs->pc < regs->gregs[0]) {
3492 /* Reset the PC to before the gUSA region, as computed from
3493 R0 = region end, SP = -(region size), plus one more for the
3494 insn that actually initializes SP to the region size. */
3495 regs->pc = regs->gregs[0] + regs->gregs[15] - 2;
3496
3497 /* Reset the SP to the saved version in R1. */
3498 regs->gregs[15] = regs->gregs[1];
3499 }
3500 }
3501
3502 static void setup_sigcontext(struct target_sigcontext *sc,
3503 CPUSH4State *regs, unsigned long mask)
3504 {
3505 int i;
3506
3507 #define COPY(x) __put_user(regs->x, &sc->sc_##x)
3508 COPY(gregs[0]); COPY(gregs[1]);
3509 COPY(gregs[2]); COPY(gregs[3]);
3510 COPY(gregs[4]); COPY(gregs[5]);
3511 COPY(gregs[6]); COPY(gregs[7]);
3512 COPY(gregs[8]); COPY(gregs[9]);
3513 COPY(gregs[10]); COPY(gregs[11]);
3514 COPY(gregs[12]); COPY(gregs[13]);
3515 COPY(gregs[14]); COPY(gregs[15]);
3516 COPY(gbr); COPY(mach);
3517 COPY(macl); COPY(pr);
3518 COPY(sr); COPY(pc);
3519 #undef COPY
3520
3521 for (i=0; i<16; i++) {
3522 __put_user(regs->fregs[i], &sc->sc_fpregs[i]);
3523 }
3524 __put_user(regs->fpscr, &sc->sc_fpscr);
3525 __put_user(regs->fpul, &sc->sc_fpul);
3526
3527 /* non-iBCS2 extensions.. */
3528 __put_user(mask, &sc->oldmask);
3529 }
3530
3531 static void restore_sigcontext(CPUSH4State *regs, struct target_sigcontext *sc)
3532 {
3533 int i;
3534
3535 #define COPY(x) __get_user(regs->x, &sc->sc_##x)
3536 COPY(gregs[0]); COPY(gregs[1]);
3537 COPY(gregs[2]); COPY(gregs[3]);
3538 COPY(gregs[4]); COPY(gregs[5]);
3539 COPY(gregs[6]); COPY(gregs[7]);
3540 COPY(gregs[8]); COPY(gregs[9]);
3541 COPY(gregs[10]); COPY(gregs[11]);
3542 COPY(gregs[12]); COPY(gregs[13]);
3543 COPY(gregs[14]); COPY(gregs[15]);
3544 COPY(gbr); COPY(mach);
3545 COPY(macl); COPY(pr);
3546 COPY(sr); COPY(pc);
3547 #undef COPY
3548
3549 for (i=0; i<16; i++) {
3550 __get_user(regs->fregs[i], &sc->sc_fpregs[i]);
3551 }
3552 __get_user(regs->fpscr, &sc->sc_fpscr);
3553 __get_user(regs->fpul, &sc->sc_fpul);
3554
3555 regs->tra = -1; /* disable syscall checks */
3556 regs->flags &= ~(DELAY_SLOT_MASK | GUSA_MASK);
3557 }
3558
3559 static void setup_frame(int sig, struct target_sigaction *ka,
3560 target_sigset_t *set, CPUSH4State *regs)
3561 {
3562 struct target_sigframe *frame;
3563 abi_ulong frame_addr;
3564 int i;
3565
3566 unwind_gusa(regs);
3567
3568 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
3569 trace_user_setup_frame(regs, frame_addr);
3570 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
3571 goto give_sigsegv;
3572 }
3573
3574 setup_sigcontext(&frame->sc, regs, set->sig[0]);
3575
3576 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
3577 __put_user(set->sig[i + 1], &frame->extramask[i]);
3578 }
3579
3580 /* Set up to return from userspace. If provided, use a stub
3581 already in userspace. */
3582 if (ka->sa_flags & TARGET_SA_RESTORER) {
3583 regs->pr = (unsigned long) ka->sa_restorer;
3584 } else {
3585 /* Generate return code (system call to sigreturn) */
3586 abi_ulong retcode_addr = frame_addr +
3587 offsetof(struct target_sigframe, retcode);
3588 __put_user(MOVW(2), &frame->retcode[0]);
3589 __put_user(TRAP_NOARG, &frame->retcode[1]);
3590 __put_user((TARGET_NR_sigreturn), &frame->retcode[2]);
3591 regs->pr = (unsigned long) retcode_addr;
3592 }
3593
3594 /* Set up registers for signal handler */
3595 regs->gregs[15] = frame_addr;
3596 regs->gregs[4] = sig; /* Arg for signal handler */
3597 regs->gregs[5] = 0;
3598 regs->gregs[6] = frame_addr += offsetof(typeof(*frame), sc);
3599 regs->pc = (unsigned long) ka->_sa_handler;
3600 regs->flags &= ~(DELAY_SLOT_MASK | GUSA_MASK);
3601
3602 unlock_user_struct(frame, frame_addr, 1);
3603 return;
3604
3605 give_sigsegv:
3606 unlock_user_struct(frame, frame_addr, 1);
3607 force_sigsegv(sig);
3608 }
3609
3610 static void setup_rt_frame(int sig, struct target_sigaction *ka,
3611 target_siginfo_t *info,
3612 target_sigset_t *set, CPUSH4State *regs)
3613 {
3614 struct target_rt_sigframe *frame;
3615 abi_ulong frame_addr;
3616 int i;
3617
3618 unwind_gusa(regs);
3619
3620 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
3621 trace_user_setup_rt_frame(regs, frame_addr);
3622 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
3623 goto give_sigsegv;
3624 }
3625
3626 tswap_siginfo(&frame->info, info);
3627
3628 /* Create the ucontext. */
3629 __put_user(0, &frame->uc.tuc_flags);
3630 __put_user(0, (unsigned long *)&frame->uc.tuc_link);
3631 __put_user((unsigned long)target_sigaltstack_used.ss_sp,
3632 &frame->uc.tuc_stack.ss_sp);
3633 __put_user(sas_ss_flags(regs->gregs[15]),
3634 &frame->uc.tuc_stack.ss_flags);
3635 __put_user(target_sigaltstack_used.ss_size,
3636 &frame->uc.tuc_stack.ss_size);
3637 setup_sigcontext(&frame->uc.tuc_mcontext,
3638 regs, set->sig[0]);
3639 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
3640 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
3641 }
3642
3643 /* Set up to return from userspace. If provided, use a stub
3644 already in userspace. */
3645 if (ka->sa_flags & TARGET_SA_RESTORER) {
3646 regs->pr = (unsigned long) ka->sa_restorer;
3647 } else {
3648 /* Generate return code (system call to sigreturn) */
3649 abi_ulong retcode_addr = frame_addr +
3650 offsetof(struct target_rt_sigframe, retcode);
3651 __put_user(MOVW(2), &frame->retcode[0]);
3652 __put_user(TRAP_NOARG, &frame->retcode[1]);
3653 __put_user((TARGET_NR_rt_sigreturn), &frame->retcode[2]);
3654 regs->pr = (unsigned long) retcode_addr;
3655 }
3656
3657 /* Set up registers for signal handler */
3658 regs->gregs[15] = frame_addr;
3659 regs->gregs[4] = sig; /* Arg for signal handler */
3660 regs->gregs[5] = frame_addr + offsetof(typeof(*frame), info);
3661 regs->gregs[6] = frame_addr + offsetof(typeof(*frame), uc);
3662 regs->pc = (unsigned long) ka->_sa_handler;
3663 regs->flags &= ~(DELAY_SLOT_MASK | GUSA_MASK);
3664
3665 unlock_user_struct(frame, frame_addr, 1);
3666 return;
3667
3668 give_sigsegv:
3669 unlock_user_struct(frame, frame_addr, 1);
3670 force_sigsegv(sig);
3671 }
3672
3673 long do_sigreturn(CPUSH4State *regs)
3674 {
3675 struct target_sigframe *frame;
3676 abi_ulong frame_addr;
3677 sigset_t blocked;
3678 target_sigset_t target_set;
3679 int i;
3680 int err = 0;
3681
3682 frame_addr = regs->gregs[15];
3683 trace_user_do_sigreturn(regs, frame_addr);
3684 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
3685 goto badframe;
3686 }
3687
3688 __get_user(target_set.sig[0], &frame->sc.oldmask);
3689 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3690 __get_user(target_set.sig[i], &frame->extramask[i - 1]);
3691 }
3692
3693 if (err)
3694 goto badframe;
3695
3696 target_to_host_sigset_internal(&blocked, &target_set);
3697 set_sigmask(&blocked);
3698
3699 restore_sigcontext(regs, &frame->sc);
3700
3701 unlock_user_struct(frame, frame_addr, 0);
3702 return -TARGET_QEMU_ESIGRETURN;
3703
3704 badframe:
3705 unlock_user_struct(frame, frame_addr, 0);
3706 force_sig(TARGET_SIGSEGV);
3707 return -TARGET_QEMU_ESIGRETURN;
3708 }
3709
3710 long do_rt_sigreturn(CPUSH4State *regs)
3711 {
3712 struct target_rt_sigframe *frame;
3713 abi_ulong frame_addr;
3714 sigset_t blocked;
3715
3716 frame_addr = regs->gregs[15];
3717 trace_user_do_rt_sigreturn(regs, frame_addr);
3718 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
3719 goto badframe;
3720 }
3721
3722 target_to_host_sigset(&blocked, &frame->uc.tuc_sigmask);
3723 set_sigmask(&blocked);
3724
3725 restore_sigcontext(regs, &frame->uc.tuc_mcontext);
3726
3727 if (do_sigaltstack(frame_addr +
3728 offsetof(struct target_rt_sigframe, uc.tuc_stack),
3729 0, get_sp_from_cpustate(regs)) == -EFAULT) {
3730 goto badframe;
3731 }
3732
3733 unlock_user_struct(frame, frame_addr, 0);
3734 return -TARGET_QEMU_ESIGRETURN;
3735
3736 badframe:
3737 unlock_user_struct(frame, frame_addr, 0);
3738 force_sig(TARGET_SIGSEGV);
3739 return -TARGET_QEMU_ESIGRETURN;
3740 }
3741 #elif defined(TARGET_MICROBLAZE)
3742
3743 struct target_sigcontext {
3744 struct target_pt_regs regs; /* needs to be first */
3745 uint32_t oldmask;
3746 };
3747
3748 struct target_stack_t {
3749 abi_ulong ss_sp;
3750 int ss_flags;
3751 unsigned int ss_size;
3752 };
3753
3754 struct target_ucontext {
3755 abi_ulong tuc_flags;
3756 abi_ulong tuc_link;
3757 struct target_stack_t tuc_stack;
3758 struct target_sigcontext tuc_mcontext;
3759 uint32_t tuc_extramask[TARGET_NSIG_WORDS - 1];
3760 };
3761
3762 /* Signal frames. */
3763 struct target_signal_frame {
3764 struct target_ucontext uc;
3765 uint32_t extramask[TARGET_NSIG_WORDS - 1];
3766 uint32_t tramp[2];
3767 };
3768
3769 struct rt_signal_frame {
3770 siginfo_t info;
3771 ucontext_t uc;
3772 uint32_t tramp[2];
3773 };
3774
3775 static void setup_sigcontext(struct target_sigcontext *sc, CPUMBState *env)
3776 {
3777 __put_user(env->regs[0], &sc->regs.r0);
3778 __put_user(env->regs[1], &sc->regs.r1);
3779 __put_user(env->regs[2], &sc->regs.r2);
3780 __put_user(env->regs[3], &sc->regs.r3);
3781 __put_user(env->regs[4], &sc->regs.r4);
3782 __put_user(env->regs[5], &sc->regs.r5);
3783 __put_user(env->regs[6], &sc->regs.r6);
3784 __put_user(env->regs[7], &sc->regs.r7);
3785 __put_user(env->regs[8], &sc->regs.r8);
3786 __put_user(env->regs[9], &sc->regs.r9);
3787 __put_user(env->regs[10], &sc->regs.r10);
3788 __put_user(env->regs[11], &sc->regs.r11);
3789 __put_user(env->regs[12], &sc->regs.r12);
3790 __put_user(env->regs[13], &sc->regs.r13);
3791 __put_user(env->regs[14], &sc->regs.r14);
3792 __put_user(env->regs[15], &sc->regs.r15);
3793 __put_user(env->regs[16], &sc->regs.r16);
3794 __put_user(env->regs[17], &sc->regs.r17);
3795 __put_user(env->regs[18], &sc->regs.r18);
3796 __put_user(env->regs[19], &sc->regs.r19);
3797 __put_user(env->regs[20], &sc->regs.r20);
3798 __put_user(env->regs[21], &sc->regs.r21);
3799 __put_user(env->regs[22], &sc->regs.r22);
3800 __put_user(env->regs[23], &sc->regs.r23);
3801 __put_user(env->regs[24], &sc->regs.r24);
3802 __put_user(env->regs[25], &sc->regs.r25);
3803 __put_user(env->regs[26], &sc->regs.r26);
3804 __put_user(env->regs[27], &sc->regs.r27);
3805 __put_user(env->regs[28], &sc->regs.r28);
3806 __put_user(env->regs[29], &sc->regs.r29);
3807 __put_user(env->regs[30], &sc->regs.r30);
3808 __put_user(env->regs[31], &sc->regs.r31);
3809 __put_user(env->sregs[SR_PC], &sc->regs.pc);
3810 }
3811
3812 static void restore_sigcontext(struct target_sigcontext *sc, CPUMBState *env)
3813 {
3814 __get_user(env->regs[0], &sc->regs.r0);
3815 __get_user(env->regs[1], &sc->regs.r1);
3816 __get_user(env->regs[2], &sc->regs.r2);
3817 __get_user(env->regs[3], &sc->regs.r3);
3818 __get_user(env->regs[4], &sc->regs.r4);
3819 __get_user(env->regs[5], &sc->regs.r5);
3820 __get_user(env->regs[6], &sc->regs.r6);
3821 __get_user(env->regs[7], &sc->regs.r7);
3822 __get_user(env->regs[8], &sc->regs.r8);
3823 __get_user(env->regs[9], &sc->regs.r9);
3824 __get_user(env->regs[10], &sc->regs.r10);
3825 __get_user(env->regs[11], &sc->regs.r11);
3826 __get_user(env->regs[12], &sc->regs.r12);
3827 __get_user(env->regs[13], &sc->regs.r13);
3828 __get_user(env->regs[14], &sc->regs.r14);
3829 __get_user(env->regs[15], &sc->regs.r15);
3830 __get_user(env->regs[16], &sc->regs.r16);
3831 __get_user(env->regs[17], &sc->regs.r17);
3832 __get_user(env->regs[18], &sc->regs.r18);
3833 __get_user(env->regs[19], &sc->regs.r19);
3834 __get_user(env->regs[20], &sc->regs.r20);
3835 __get_user(env->regs[21], &sc->regs.r21);
3836 __get_user(env->regs[22], &sc->regs.r22);
3837 __get_user(env->regs[23], &sc->regs.r23);
3838 __get_user(env->regs[24], &sc->regs.r24);
3839 __get_user(env->regs[25], &sc->regs.r25);
3840 __get_user(env->regs[26], &sc->regs.r26);
3841 __get_user(env->regs[27], &sc->regs.r27);
3842 __get_user(env->regs[28], &sc->regs.r28);
3843 __get_user(env->regs[29], &sc->regs.r29);
3844 __get_user(env->regs[30], &sc->regs.r30);
3845 __get_user(env->regs[31], &sc->regs.r31);
3846 __get_user(env->sregs[SR_PC], &sc->regs.pc);
3847 }
3848
3849 static abi_ulong get_sigframe(struct target_sigaction *ka,
3850 CPUMBState *env, int frame_size)
3851 {
3852 abi_ulong sp = env->regs[1];
3853
3854 if ((ka->sa_flags & TARGET_SA_ONSTACK) != 0 && !on_sig_stack(sp)) {
3855 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
3856 }
3857
3858 return ((sp - frame_size) & -8UL);
3859 }
3860
3861 static void setup_frame(int sig, struct target_sigaction *ka,
3862 target_sigset_t *set, CPUMBState *env)
3863 {
3864 struct target_signal_frame *frame;
3865 abi_ulong frame_addr;
3866 int i;
3867
3868 frame_addr = get_sigframe(ka, env, sizeof *frame);
3869 trace_user_setup_frame(env, frame_addr);
3870 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3871 goto badframe;
3872
3873 /* Save the mask. */
3874 __put_user(set->sig[0], &frame->uc.tuc_mcontext.oldmask);
3875
3876 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3877 __put_user(set->sig[i], &frame->extramask[i - 1]);
3878 }
3879
3880 setup_sigcontext(&frame->uc.tuc_mcontext, env);
3881
3882 /* Set up to return from userspace. If provided, use a stub
3883 already in userspace. */
3884 /* minus 8 is offset to cater for "rtsd r15,8" offset */
3885 if (ka->sa_flags & TARGET_SA_RESTORER) {
3886 env->regs[15] = ((unsigned long)ka->sa_restorer)-8;
3887 } else {
3888 uint32_t t;
3889 /* Note, these encodings are _big endian_! */
3890 /* addi r12, r0, __NR_sigreturn */
3891 t = 0x31800000UL | TARGET_NR_sigreturn;
3892 __put_user(t, frame->tramp + 0);
3893 /* brki r14, 0x8 */
3894 t = 0xb9cc0008UL;
3895 __put_user(t, frame->tramp + 1);
3896
3897 /* Return from sighandler will jump to the tramp.
3898 Negative 8 offset because return is rtsd r15, 8 */
3899 env->regs[15] = frame_addr + offsetof(struct target_signal_frame, tramp)
3900 - 8;
3901 }
3902
3903 /* Set up registers for signal handler */
3904 env->regs[1] = frame_addr;
3905 /* Signal handler args: */
3906 env->regs[5] = sig; /* Arg 0: signum */
3907 env->regs[6] = 0;
3908 /* arg 1: sigcontext */
3909 env->regs[7] = frame_addr += offsetof(typeof(*frame), uc);
3910
3911 /* Offset of 4 to handle microblaze rtid r14, 0 */
3912 env->sregs[SR_PC] = (unsigned long)ka->_sa_handler;
3913
3914 unlock_user_struct(frame, frame_addr, 1);
3915 return;
3916 badframe:
3917 force_sigsegv(sig);
3918 }
3919
3920 static void setup_rt_frame(int sig, struct target_sigaction *ka,
3921 target_siginfo_t *info,
3922 target_sigset_t *set, CPUMBState *env)
3923 {
3924 fprintf(stderr, "Microblaze setup_rt_frame: not implemented\n");
3925 }
3926
3927 long do_sigreturn(CPUMBState *env)
3928 {
3929 struct target_signal_frame *frame;
3930 abi_ulong frame_addr;
3931 target_sigset_t target_set;
3932 sigset_t set;
3933 int i;
3934
3935 frame_addr = env->regs[R_SP];
3936 trace_user_do_sigreturn(env, frame_addr);
3937 /* Make sure the guest isn't playing games. */
3938 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
3939 goto badframe;
3940
3941 /* Restore blocked signals */
3942 __get_user(target_set.sig[0], &frame->uc.tuc_mcontext.oldmask);
3943 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3944 __get_user(target_set.sig[i], &frame->extramask[i - 1]);
3945 }
3946 target_to_host_sigset_internal(&set, &target_set);
3947 set_sigmask(&set);
3948
3949 restore_sigcontext(&frame->uc.tuc_mcontext, env);
3950 /* We got here through a sigreturn syscall, our path back is via an
3951 rtb insn so setup r14 for that. */
3952 env->regs[14] = env->sregs[SR_PC];
3953
3954 unlock_user_struct(frame, frame_addr, 0);
3955 return -TARGET_QEMU_ESIGRETURN;
3956 badframe:
3957 force_sig(TARGET_SIGSEGV);
3958 return -TARGET_QEMU_ESIGRETURN;
3959 }
3960
3961 long do_rt_sigreturn(CPUMBState *env)
3962 {
3963 trace_user_do_rt_sigreturn(env, 0);
3964 fprintf(stderr, "Microblaze do_rt_sigreturn: not implemented\n");
3965 return -TARGET_ENOSYS;
3966 }
3967
3968 #elif defined(TARGET_CRIS)
3969
3970 struct target_sigcontext {
3971 struct target_pt_regs regs; /* needs to be first */
3972 uint32_t oldmask;
3973 uint32_t usp; /* usp before stacking this gunk on it */
3974 };
3975
3976 /* Signal frames. */
3977 struct target_signal_frame {
3978 struct target_sigcontext sc;
3979 uint32_t extramask[TARGET_NSIG_WORDS - 1];
3980 uint16_t retcode[4]; /* Trampoline code. */
3981 };
3982
3983 struct rt_signal_frame {
3984 siginfo_t *pinfo;
3985 void *puc;
3986 siginfo_t info;
3987 ucontext_t uc;
3988 uint16_t retcode[4]; /* Trampoline code. */
3989 };
3990
3991 static void setup_sigcontext(struct target_sigcontext *sc, CPUCRISState *env)
3992 {
3993 __put_user(env->regs[0], &sc->regs.r0);
3994 __put_user(env->regs[1], &sc->regs.r1);
3995 __put_user(env->regs[2], &sc->regs.r2);
3996 __put_user(env->regs[3], &sc->regs.r3);
3997 __put_user(env->regs[4], &sc->regs.r4);
3998 __put_user(env->regs[5], &sc->regs.r5);
3999 __put_user(env->regs[6], &sc->regs.r6);
4000 __put_user(env->regs[7], &sc->regs.r7);
4001 __put_user(env->regs[8], &sc->regs.r8);
4002 __put_user(env->regs[9], &sc->regs.r9);
4003 __put_user(env->regs[10], &sc->regs.r10);
4004 __put_user(env->regs[11], &sc->regs.r11);
4005 __put_user(env->regs[12], &sc->regs.r12);
4006 __put_user(env->regs[13], &sc->regs.r13);
4007 __put_user(env->regs[14], &sc->usp);
4008 __put_user(env->regs[15], &sc->regs.acr);
4009 __put_user(env->pregs[PR_MOF], &sc->regs.mof);
4010 __put_user(env->pregs[PR_SRP], &sc->regs.srp);
4011 __put_user(env->pc, &sc->regs.erp);
4012 }
4013
4014 static void restore_sigcontext(struct target_sigcontext *sc, CPUCRISState *env)
4015 {
4016 __get_user(env->regs[0], &sc->regs.r0);
4017 __get_user(env->regs[1], &sc->regs.r1);
4018 __get_user(env->regs[2], &sc->regs.r2);
4019 __get_user(env->regs[3], &sc->regs.r3);
4020 __get_user(env->regs[4], &sc->regs.r4);
4021 __get_user(env->regs[5], &sc->regs.r5);
4022 __get_user(env->regs[6], &sc->regs.r6);
4023 __get_user(env->regs[7], &sc->regs.r7);
4024 __get_user(env->regs[8], &sc->regs.r8);
4025 __get_user(env->regs[9], &sc->regs.r9);
4026 __get_user(env->regs[10], &sc->regs.r10);
4027 __get_user(env->regs[11], &sc->regs.r11);
4028 __get_user(env->regs[12], &sc->regs.r12);
4029 __get_user(env->regs[13], &sc->regs.r13);
4030 __get_user(env->regs[14], &sc->usp);
4031 __get_user(env->regs[15], &sc->regs.acr);
4032 __get_user(env->pregs[PR_MOF], &sc->regs.mof);
4033 __get_user(env->pregs[PR_SRP], &sc->regs.srp);
4034 __get_user(env->pc, &sc->regs.erp);
4035 }
4036
4037 static abi_ulong get_sigframe(CPUCRISState *env, int framesize)
4038 {
4039 abi_ulong sp;
4040 /* Align the stack downwards to 4. */
4041 sp = (env->regs[R_SP] & ~3);
4042 return sp - framesize;
4043 }
4044
4045 static void setup_frame(int sig, struct target_sigaction *ka,
4046 target_sigset_t *set, CPUCRISState *env)
4047 {
4048 struct target_signal_frame *frame;
4049 abi_ulong frame_addr;
4050 int i;
4051
4052 frame_addr = get_sigframe(env, sizeof *frame);
4053 trace_user_setup_frame(env, frame_addr);
4054 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
4055 goto badframe;
4056
4057 /*
4058 * The CRIS signal return trampoline. A real linux/CRIS kernel doesn't
4059 * use this trampoline anymore but it sets it up for GDB.
4060 * In QEMU, using the trampoline simplifies things a bit so we use it.
4061 *
4062 * This is movu.w __NR_sigreturn, r9; break 13;
4063 */
4064 __put_user(0x9c5f, frame->retcode+0);
4065 __put_user(TARGET_NR_sigreturn,
4066 frame->retcode + 1);
4067 __put_user(0xe93d, frame->retcode + 2);
4068
4069 /* Save the mask. */
4070 __put_user(set->sig[0], &frame->sc.oldmask);
4071
4072 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
4073 __put_user(set->sig[i], &frame->extramask[i - 1]);
4074 }
4075
4076 setup_sigcontext(&frame->sc, env);
4077
4078 /* Move the stack and setup the arguments for the handler. */
4079 env->regs[R_SP] = frame_addr;
4080 env->regs[10] = sig;
4081 env->pc = (unsigned long) ka->_sa_handler;
4082 /* Link SRP so the guest returns through the trampoline. */
4083 env->pregs[PR_SRP] = frame_addr + offsetof(typeof(*frame), retcode);
4084
4085 unlock_user_struct(frame, frame_addr, 1);
4086 return;
4087 badframe:
4088 force_sigsegv(sig);
4089 }
4090
4091 static void setup_rt_frame(int sig, struct target_sigaction *ka,
4092 target_siginfo_t *info,
4093 target_sigset_t *set, CPUCRISState *env)
4094 {
4095 fprintf(stderr, "CRIS setup_rt_frame: not implemented\n");
4096 }
4097
4098 long do_sigreturn(CPUCRISState *env)
4099 {
4100 struct target_signal_frame *frame;
4101 abi_ulong frame_addr;
4102 target_sigset_t target_set;
4103 sigset_t set;
4104 int i;
4105
4106 frame_addr = env->regs[R_SP];
4107 trace_user_do_sigreturn(env, frame_addr);
4108 /* Make sure the guest isn't playing games. */
4109 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1)) {
4110 goto badframe;
4111 }
4112
4113 /* Restore blocked signals */
4114 __get_user(target_set.sig[0], &frame->sc.oldmask);
4115 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
4116 __get_user(target_set.sig[i], &frame->extramask[i - 1]);
4117 }
4118 target_to_host_sigset_internal(&set, &target_set);
4119 set_sigmask(&set);
4120
4121 restore_sigcontext(&frame->sc, env);
4122 unlock_user_struct(frame, frame_addr, 0);
4123 return -TARGET_QEMU_ESIGRETURN;
4124 badframe:
4125 force_sig(TARGET_SIGSEGV);
4126 return -TARGET_QEMU_ESIGRETURN;
4127 }
4128
4129 long do_rt_sigreturn(CPUCRISState *env)
4130 {
4131 trace_user_do_rt_sigreturn(env, 0);
4132 fprintf(stderr, "CRIS do_rt_sigreturn: not implemented\n");
4133 return -TARGET_ENOSYS;
4134 }
4135
4136 #elif defined(TARGET_NIOS2)
4137
4138 #define MCONTEXT_VERSION 2
4139
4140 struct target_sigcontext {
4141 int version;
4142 unsigned long gregs[32];
4143 };
4144
4145 struct target_ucontext {
4146 abi_ulong tuc_flags;
4147 abi_ulong tuc_link;
4148 target_stack_t tuc_stack;
4149 struct target_sigcontext tuc_mcontext;
4150 target_sigset_t tuc_sigmask; /* mask last for extensibility */
4151 };
4152
4153 struct target_rt_sigframe {
4154 struct target_siginfo info;
4155 struct target_ucontext uc;
4156 };
4157
4158 static unsigned long sigsp(unsigned long sp, struct target_sigaction *ka)
4159 {
4160 if (unlikely((ka->sa_flags & SA_ONSTACK)) && !sas_ss_flags(sp)) {
4161 #ifdef CONFIG_STACK_GROWSUP
4162 return target_sigaltstack_used.ss_sp;
4163 #else
4164 return target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
4165 #endif
4166 }
4167 return sp;
4168 }
4169
4170 static int rt_setup_ucontext(struct target_ucontext *uc, CPUNios2State *env)
4171 {
4172 unsigned long *gregs = uc->tuc_mcontext.gregs;
4173
4174 __put_user(MCONTEXT_VERSION, &uc->tuc_mcontext.version);
4175 __put_user(env->regs[1], &gregs[0]);
4176 __put_user(env->regs[2], &gregs[1]);
4177 __put_user(env->regs[3], &gregs[2]);
4178 __put_user(env->regs[4], &gregs[3]);
4179 __put_user(env->regs[5], &gregs[4]);
4180 __put_user(env->regs[6], &gregs[5]);
4181 __put_user(env->regs[7], &gregs[6]);
4182 __put_user(env->regs[8], &gregs[7]);
4183 __put_user(env->regs[9], &gregs[8]);
4184 __put_user(env->regs[10], &gregs[9]);
4185 __put_user(env->regs[11], &gregs[10]);
4186 __put_user(env->regs[12], &gregs[11]);
4187 __put_user(env->regs[13], &gregs[12]);
4188 __put_user(env->regs[14], &gregs[13]);
4189 __put_user(env->regs[15], &gregs[14]);
4190 __put_user(env->regs[16], &gregs[15]);
4191 __put_user(env->regs[17], &gregs[16]);
4192 __put_user(env->regs[18], &gregs[17]);
4193 __put_user(env->regs[19], &gregs[18]);
4194 __put_user(env->regs[20], &gregs[19]);
4195 __put_user(env->regs[21], &gregs[20]);
4196 __put_user(env->regs[22], &gregs[21]);
4197 __put_user(env->regs[23], &gregs[22]);
4198 __put_user(env->regs[R_RA], &gregs[23]);
4199 __put_user(env->regs[R_FP], &gregs[24]);
4200 __put_user(env->regs[R_GP], &gregs[25]);
4201 __put_user(env->regs[R_EA], &gregs[27]);
4202 __put_user(env->regs[R_SP], &gregs[28]);
4203
4204 return 0;
4205 }
4206
4207 static int rt_restore_ucontext(CPUNios2State *env, struct target_ucontext *uc,
4208 int *pr2)
4209 {
4210 int temp;
4211 abi_ulong off, frame_addr = env->regs[R_SP];
4212 unsigned long *gregs = uc->tuc_mcontext.gregs;
4213 int err;
4214
4215 /* Always make any pending restarted system calls return -EINTR */
4216 /* current->restart_block.fn = do_no_restart_syscall; */
4217
4218 __get_user(temp, &uc->tuc_mcontext.version);
4219 if (temp != MCONTEXT_VERSION) {
4220 return 1;
4221 }
4222
4223 /* restore passed registers */
4224 __get_user(env->regs[1], &gregs[0]);
4225 __get_user(env->regs[2], &gregs[1]);
4226 __get_user(env->regs[3], &gregs[2]);
4227 __get_user(env->regs[4], &gregs[3]);
4228 __get_user(env->regs[5], &gregs[4]);
4229 __get_user(env->regs[6], &gregs[5]);
4230 __get_user(env->regs[7], &gregs[6]);
4231 __get_user(env->regs[8], &gregs[7]);
4232 __get_user(env->regs[9], &gregs[8]);
4233 __get_user(env->regs[10], &gregs[9]);
4234 __get_user(env->regs[11], &gregs[10]);
4235 __get_user(env->regs[12], &gregs[11]);
4236 __get_user(env->regs[13], &gregs[12]);
4237 __get_user(env->regs[14], &gregs[13]);
4238 __get_user(env->regs[15], &gregs[14]);
4239 __get_user(env->regs[16], &gregs[15]);
4240 __get_user(env->regs[17], &gregs[16]);
4241 __get_user(env->regs[18], &gregs[17]);
4242 __get_user(env->regs[19], &gregs[18]);
4243 __get_user(env->regs[20], &gregs[19]);
4244 __get_user(env->regs[21], &gregs[20]);
4245 __get_user(env->regs[22], &gregs[21]);
4246 __get_user(env->regs[23], &gregs[22]);
4247 /* gregs[23] is handled below */
4248 /* Verify, should this be settable */
4249 __get_user(env->regs[R_FP], &gregs[24]);
4250 /* Verify, should this be settable */
4251 __get_user(env->regs[R_GP], &gregs[25]);
4252 /* Not really necessary no user settable bits */
4253 __get_user(temp, &gregs[26]);
4254 __get_user(env->regs[R_EA], &gregs[27]);
4255
4256 __get_user(env->regs[R_RA], &gregs[23]);
4257 __get_user(env->regs[R_SP], &gregs[28]);
4258
4259 off = offsetof(struct target_rt_sigframe, uc.tuc_stack);
4260 err = do_sigaltstack(frame_addr + off, 0, get_sp_from_cpustate(env));
4261 if (err == -EFAULT) {
4262 return 1;
4263 }
4264
4265 *pr2 = env->regs[2];
4266 return 0;
4267 }
4268
4269 static void *get_sigframe(struct target_sigaction *ka, CPUNios2State *env,
4270 size_t frame_size)
4271 {
4272 unsigned long usp;
4273
4274 /* Default to using normal stack. */
4275 usp = env->regs[R_SP];
4276
4277 /* This is the X/Open sanctioned signal stack switching. */
4278 usp = sigsp(usp, ka);
4279
4280 /* Verify, is it 32 or 64 bit aligned */
4281 return (void *)((usp - frame_size) & -8UL);
4282 }
4283
4284 static void setup_rt_frame(int sig, struct target_sigaction *ka,
4285 target_siginfo_t *info,
4286 target_sigset_t *set,
4287 CPUNios2State *env)
4288 {
4289 struct target_rt_sigframe *frame;
4290 int i, err = 0;
4291
4292 frame = get_sigframe(ka, env, sizeof(*frame));
4293
4294 if (ka->sa_flags & SA_SIGINFO) {
4295 tswap_siginfo(&frame->info, info);
4296 }
4297
4298 /* Create the ucontext. */
4299 __put_user(0, &frame->uc.tuc_flags);
4300 __put_user(0, &frame->uc.tuc_link);
4301 __put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp);
4302 __put_user(sas_ss_flags(env->regs[R_SP]), &frame->uc.tuc_stack.ss_flags);
4303 __put_user(target_sigaltstack_used.ss_size, &frame->uc.tuc_stack.ss_size);
4304 err |= rt_setup_ucontext(&frame->uc, env);
4305 for (i = 0; i < TARGET_NSIG_WORDS; i++) {
4306 __put_user((abi_ulong)set->sig[i],
4307 (abi_ulong *)&frame->uc.tuc_sigmask.sig[i]);
4308 }
4309
4310 if (err) {
4311 goto give_sigsegv;
4312 }
4313
4314 /* Set up to return from userspace; jump to fixed address sigreturn
4315 trampoline on kuser page. */
4316 env->regs[R_RA] = (unsigned long) (0x1044);
4317
4318 /* Set up registers for signal handler */
4319 env->regs[R_SP] = (unsigned long) frame;
4320 env->regs[4] = (unsigned long) sig;
4321 env->regs[5] = (unsigned long) &frame->info;
4322 env->regs[6] = (unsigned long) &frame->uc;
4323 env->regs[R_EA] = (unsigned long) ka->_sa_handler;
4324 return;
4325
4326 give_sigsegv:
4327 if (sig == TARGET_SIGSEGV) {
4328 ka->_sa_handler = TARGET_SIG_DFL;
4329 }
4330 force_sigsegv(sig);
4331 return;
4332 }
4333
4334 long do_sigreturn(CPUNios2State *env)
4335 {
4336 trace_user_do_sigreturn(env, 0);
4337 fprintf(stderr, "do_sigreturn: not implemented\n");
4338 return -TARGET_ENOSYS;
4339 }
4340
4341 long do_rt_sigreturn(CPUNios2State *env)
4342 {
4343 /* Verify, can we follow the stack back */
4344 abi_ulong frame_addr = env->regs[R_SP];
4345 struct target_rt_sigframe *frame;
4346 sigset_t set;
4347 int rval;
4348
4349 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
4350 goto badframe;
4351 }
4352
4353 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
4354 do_sigprocmask(SIG_SETMASK, &set, NULL);
4355
4356 if (rt_restore_ucontext(env, &frame->uc, &rval)) {
4357 goto badframe;
4358 }
4359
4360 unlock_user_struct(frame, frame_addr, 0);
4361 return rval;
4362
4363 badframe:
4364 unlock_user_struct(frame, frame_addr, 0);
4365 force_sig(TARGET_SIGSEGV);
4366 return 0;
4367 }
4368 /* TARGET_NIOS2 */
4369
4370 #elif defined(TARGET_OPENRISC)
4371
4372 struct target_sigcontext {
4373 struct target_pt_regs regs;
4374 abi_ulong oldmask;
4375 abi_ulong usp;
4376 };
4377
4378 struct target_ucontext {
4379 abi_ulong tuc_flags;
4380 abi_ulong tuc_link;
4381 target_stack_t tuc_stack;
4382 struct target_sigcontext tuc_mcontext;
4383 target_sigset_t tuc_sigmask; /* mask last for extensibility */
4384 };
4385
4386 struct target_rt_sigframe {
4387 abi_ulong pinfo;
4388 uint64_t puc;
4389 struct target_siginfo info;
4390 struct target_sigcontext sc;
4391 struct target_ucontext uc;
4392 unsigned char retcode[16]; /* trampoline code */
4393 };
4394
4395 /* This is the asm-generic/ucontext.h version */
4396 #if 0
4397 static int restore_sigcontext(CPUOpenRISCState *regs,
4398 struct target_sigcontext *sc)
4399 {
4400 unsigned int err = 0;
4401 unsigned long old_usp;
4402
4403 /* Alwys make any pending restarted system call return -EINTR */
4404 current_thread_info()->restart_block.fn = do_no_restart_syscall;
4405
4406 /* restore the regs from &sc->regs (same as sc, since regs is first)
4407 * (sc is already checked for VERIFY_READ since the sigframe was
4408 * checked in sys_sigreturn previously)
4409 */
4410
4411 if (copy_from_user(regs, &sc, sizeof(struct target_pt_regs))) {
4412 goto badframe;
4413 }
4414
4415 /* make sure the U-flag is set so user-mode cannot fool us */
4416
4417 regs->sr &= ~SR_SM;
4418
4419 /* restore the old USP as it was before we stacked the sc etc.
4420 * (we cannot just pop the sigcontext since we aligned the sp and
4421 * stuff after pushing it)
4422 */
4423
4424 __get_user(old_usp, &sc->usp);
4425 phx_signal("old_usp 0x%lx", old_usp);
4426
4427 __PHX__ REALLY /* ??? */
4428 wrusp(old_usp);
4429 regs->gpr[1] = old_usp;
4430
4431 /* TODO: the other ports use regs->orig_XX to disable syscall checks
4432 * after this completes, but we don't use that mechanism. maybe we can
4433 * use it now ?
4434 */
4435
4436 return err;
4437
4438 badframe:
4439 return 1;
4440 }
4441 #endif
4442
4443 /* Set up a signal frame. */
4444
4445 static void setup_sigcontext(struct target_sigcontext *sc,
4446 CPUOpenRISCState *regs,
4447 unsigned long mask)
4448 {
4449 unsigned long usp = cpu_get_gpr(regs, 1);
4450
4451 /* copy the regs. they are first in sc so we can use sc directly */
4452
4453 /*copy_to_user(&sc, regs, sizeof(struct target_pt_regs));*/
4454
4455 /* Set the frametype to CRIS_FRAME_NORMAL for the execution of
4456 the signal handler. The frametype will be restored to its previous
4457 value in restore_sigcontext. */
4458 /*regs->frametype = CRIS_FRAME_NORMAL;*/
4459
4460 /* then some other stuff */
4461 __put_user(mask, &sc->oldmask);
4462 __put_user(usp, &sc->usp);
4463 }
4464
4465 static inline unsigned long align_sigframe(unsigned long sp)
4466 {
4467 return sp & ~3UL;
4468 }
4469
4470 static inline abi_ulong get_sigframe(struct target_sigaction *ka,
4471 CPUOpenRISCState *regs,
4472 size_t frame_size)
4473 {
4474 unsigned long sp = cpu_get_gpr(regs, 1);
4475 int onsigstack = on_sig_stack(sp);
4476
4477 /* redzone */
4478 /* This is the X/Open sanctioned signal stack switching. */
4479 if ((ka->sa_flags & TARGET_SA_ONSTACK) != 0 && !onsigstack) {
4480 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
4481 }
4482
4483 sp = align_sigframe(sp - frame_size);
4484
4485 /*
4486 * If we are on the alternate signal stack and would overflow it, don't.
4487 * Return an always-bogus address instead so we will die with SIGSEGV.
4488 */
4489
4490 if (onsigstack && !likely(on_sig_stack(sp))) {
4491 return -1L;
4492 }
4493
4494 return sp;
4495 }
4496
4497 static void setup_rt_frame(int sig, struct target_sigaction *ka,
4498 target_siginfo_t *info,
4499 target_sigset_t *set, CPUOpenRISCState *env)
4500 {
4501 int err = 0;
4502 abi_ulong frame_addr;
4503 unsigned long return_ip;
4504 struct target_rt_sigframe *frame;
4505 abi_ulong info_addr, uc_addr;
4506
4507 frame_addr = get_sigframe(ka, env, sizeof(*frame));
4508 trace_user_setup_rt_frame(env, frame_addr);
4509 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
4510 goto give_sigsegv;
4511 }
4512
4513 info_addr = frame_addr + offsetof(struct target_rt_sigframe, info);
4514 __put_user(info_addr, &frame->pinfo);
4515 uc_addr = frame_addr + offsetof(struct target_rt_sigframe, uc);
4516 __put_user(uc_addr, &frame->puc);
4517
4518 if (ka->sa_flags & SA_SIGINFO) {
4519 tswap_siginfo(&frame->info, info);
4520 }
4521
4522 /*err |= __clear_user(&frame->uc, offsetof(ucontext_t, uc_mcontext));*/
4523 __put_user(0, &frame->uc.tuc_flags);
4524 __put_user(0, &frame->uc.tuc_link);
4525 __put_user(target_sigaltstack_used.ss_sp,
4526 &frame->uc.tuc_stack.ss_sp);
4527 __put_user(sas_ss_flags(cpu_get_gpr(env, 1)),
4528 &frame->uc.tuc_stack.ss_flags);
4529 __put_user(target_sigaltstack_used.ss_size,
4530 &frame->uc.tuc_stack.ss_size);
4531 setup_sigcontext(&frame->sc, env, set->sig[0]);
4532
4533 /*err |= copy_to_user(frame->uc.tuc_sigmask, set, sizeof(*set));*/
4534
4535 /* trampoline - the desired return ip is the retcode itself */
4536 return_ip = (unsigned long)&frame->retcode;
4537 /* This is l.ori r11,r0,__NR_sigreturn, l.sys 1 */
4538 __put_user(0xa960, (short *)(frame->retcode + 0));
4539 __put_user(TARGET_NR_rt_sigreturn, (short *)(frame->retcode + 2));
4540 __put_user(0x20000001, (unsigned long *)(frame->retcode + 4));
4541 __put_user(0x15000000, (unsigned long *)(frame->retcode + 8));
4542
4543 if (err) {
4544 goto give_sigsegv;
4545 }
4546
4547 /* TODO what is the current->exec_domain stuff and invmap ? */
4548
4549 /* Set up registers for signal handler */
4550 env->pc = (unsigned long)ka->_sa_handler; /* what we enter NOW */
4551 cpu_set_gpr(env, 9, (unsigned long)return_ip); /* what we enter LATER */
4552 cpu_set_gpr(env, 3, (unsigned long)sig); /* arg 1: signo */
4553 cpu_set_gpr(env, 4, (unsigned long)&frame->info); /* arg 2: (siginfo_t*) */
4554 cpu_set_gpr(env, 5, (unsigned long)&frame->uc); /* arg 3: ucontext */
4555
4556 /* actually move the usp to reflect the stacked frame */
4557 cpu_set_gpr(env, 1, (unsigned long)frame);
4558
4559 return;
4560
4561 give_sigsegv:
4562 unlock_user_struct(frame, frame_addr, 1);
4563 force_sigsegv(sig);
4564 }
4565
4566 long do_sigreturn(CPUOpenRISCState *env)
4567 {
4568 trace_user_do_sigreturn(env, 0);
4569 fprintf(stderr, "do_sigreturn: not implemented\n");
4570 return -TARGET_ENOSYS;
4571 }
4572
4573 long do_rt_sigreturn(CPUOpenRISCState *env)
4574 {
4575 trace_user_do_rt_sigreturn(env, 0);
4576 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
4577 return -TARGET_ENOSYS;
4578 }
4579 /* TARGET_OPENRISC */
4580
4581 #elif defined(TARGET_S390X)
4582
4583 #define __NUM_GPRS 16
4584 #define __NUM_FPRS 16
4585 #define __NUM_ACRS 16
4586
4587 #define S390_SYSCALL_SIZE 2
4588 #define __SIGNAL_FRAMESIZE 160 /* FIXME: 31-bit mode -> 96 */
4589
4590 #define _SIGCONTEXT_NSIG 64
4591 #define _SIGCONTEXT_NSIG_BPW 64 /* FIXME: 31-bit mode -> 32 */
4592 #define _SIGCONTEXT_NSIG_WORDS (_SIGCONTEXT_NSIG / _SIGCONTEXT_NSIG_BPW)
4593 #define _SIGMASK_COPY_SIZE (sizeof(unsigned long)*_SIGCONTEXT_NSIG_WORDS)
4594 #define PSW_ADDR_AMODE 0x0000000000000000UL /* 0x80000000UL for 31-bit */
4595 #define S390_SYSCALL_OPCODE ((uint16_t)0x0a00)
4596
4597 typedef struct {
4598 target_psw_t psw;
4599 target_ulong gprs[__NUM_GPRS];
4600 unsigned int acrs[__NUM_ACRS];
4601 } target_s390_regs_common;
4602
4603 typedef struct {
4604 unsigned int fpc;
4605 double fprs[__NUM_FPRS];
4606 } target_s390_fp_regs;
4607
4608 typedef struct {
4609 target_s390_regs_common regs;
4610 target_s390_fp_regs fpregs;
4611 } target_sigregs;
4612
4613 struct target_sigcontext {
4614 target_ulong oldmask[_SIGCONTEXT_NSIG_WORDS];
4615 target_sigregs *sregs;
4616 };
4617
4618 typedef struct {
4619 uint8_t callee_used_stack[__SIGNAL_FRAMESIZE];
4620 struct target_sigcontext sc;
4621 target_sigregs sregs;
4622 int signo;
4623 uint8_t retcode[S390_SYSCALL_SIZE];
4624 } sigframe;
4625
4626 struct target_ucontext {
4627 target_ulong tuc_flags;
4628 struct target_ucontext *tuc_link;
4629 target_stack_t tuc_stack;
4630 target_sigregs tuc_mcontext;
4631 target_sigset_t tuc_sigmask; /* mask last for extensibility */
4632 };
4633
4634 typedef struct {
4635 uint8_t callee_used_stack[__SIGNAL_FRAMESIZE];
4636 uint8_t retcode[S390_SYSCALL_SIZE];
4637 struct target_siginfo info;
4638 struct target_ucontext uc;
4639 } rt_sigframe;
4640
4641 static inline abi_ulong
4642 get_sigframe(struct target_sigaction *ka, CPUS390XState *env, size_t frame_size)
4643 {
4644 abi_ulong sp;
4645
4646 /* Default to using normal stack */
4647 sp = env->regs[15];
4648
4649 /* This is the X/Open sanctioned signal stack switching. */
4650 if (ka->sa_flags & TARGET_SA_ONSTACK) {
4651 if (!sas_ss_flags(sp)) {
4652 sp = target_sigaltstack_used.ss_sp +
4653 target_sigaltstack_used.ss_size;
4654 }
4655 }
4656
4657 /* This is the legacy signal stack switching. */
4658 else if (/* FIXME !user_mode(regs) */ 0 &&
4659 !(ka->sa_flags & TARGET_SA_RESTORER) &&
4660 ka->sa_restorer) {
4661 sp = (abi_ulong) ka->sa_restorer;
4662 }
4663
4664 return (sp - frame_size) & -8ul;
4665 }
4666
4667 static void save_sigregs(CPUS390XState *env, target_sigregs *sregs)
4668 {
4669 int i;
4670 //save_access_regs(current->thread.acrs); FIXME
4671
4672 /* Copy a 'clean' PSW mask to the user to avoid leaking
4673 information about whether PER is currently on. */
4674 __put_user(env->psw.mask, &sregs->regs.psw.mask);
4675 __put_user(env->psw.addr, &sregs->regs.psw.addr);
4676 for (i = 0; i < 16; i++) {
4677 __put_user(env->regs[i], &sregs->regs.gprs[i]);
4678 }
4679 for (i = 0; i < 16; i++) {
4680 __put_user(env->aregs[i], &sregs->regs.acrs[i]);
4681 }
4682 /*
4683 * We have to store the fp registers to current->thread.fp_regs
4684 * to merge them with the emulated registers.
4685 */
4686 //save_fp_regs(&current->thread.fp_regs); FIXME
4687 for (i = 0; i < 16; i++) {
4688 __put_user(get_freg(env, i)->ll, &sregs->fpregs.fprs[i]);
4689 }
4690 }
4691
4692 static void setup_frame(int sig, struct target_sigaction *ka,
4693 target_sigset_t *set, CPUS390XState *env)
4694 {
4695 sigframe *frame;
4696 abi_ulong frame_addr;
4697
4698 frame_addr = get_sigframe(ka, env, sizeof(*frame));
4699 trace_user_setup_frame(env, frame_addr);
4700 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
4701 goto give_sigsegv;
4702 }
4703
4704 __put_user(set->sig[0], &frame->sc.oldmask[0]);
4705
4706 save_sigregs(env, &frame->sregs);
4707
4708 __put_user((abi_ulong)(unsigned long)&frame->sregs,
4709 (abi_ulong *)&frame->sc.sregs);
4710
4711 /* Set up to return from userspace. If provided, use a stub
4712 already in userspace. */
4713 if (ka->sa_flags & TARGET_SA_RESTORER) {
4714 env->regs[14] = (unsigned long)
4715 ka->sa_restorer | PSW_ADDR_AMODE;
4716 } else {
4717 env->regs[14] = (frame_addr + offsetof(sigframe, retcode))
4718 | PSW_ADDR_AMODE;
4719 __put_user(S390_SYSCALL_OPCODE | TARGET_NR_sigreturn,
4720 (uint16_t *)(frame->retcode));
4721 }
4722
4723 /* Set up backchain. */
4724 __put_user(env->regs[15], (abi_ulong *) frame);
4725
4726 /* Set up registers for signal handler */
4727 env->regs[15] = frame_addr;
4728 env->psw.addr = (target_ulong) ka->_sa_handler | PSW_ADDR_AMODE;
4729
4730 env->regs[2] = sig; //map_signal(sig);
4731 env->regs[3] = frame_addr += offsetof(typeof(*frame), sc);
4732
4733 /* We forgot to include these in the sigcontext.
4734 To avoid breaking binary compatibility, they are passed as args. */
4735 env->regs[4] = 0; // FIXME: no clue... current->thread.trap_no;
4736 env->regs[5] = 0; // FIXME: no clue... current->thread.prot_addr;
4737
4738 /* Place signal number on stack to allow backtrace from handler. */
4739 __put_user(env->regs[2], &frame->signo);
4740 unlock_user_struct(frame, frame_addr, 1);
4741 return;
4742
4743 give_sigsegv:
4744 force_sigsegv(sig);
4745 }
4746
4747 static void setup_rt_frame(int sig, struct target_sigaction *ka,
4748 target_siginfo_t *info,
4749 target_sigset_t *set, CPUS390XState *env)
4750 {
4751 int i;
4752 rt_sigframe *frame;
4753 abi_ulong frame_addr;
4754
4755 frame_addr = get_sigframe(ka, env, sizeof *frame);
4756 trace_user_setup_rt_frame(env, frame_addr);
4757 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
4758 goto give_sigsegv;
4759 }
4760
4761 tswap_siginfo(&frame->info, info);
4762
4763 /* Create the ucontext. */
4764 __put_user(0, &frame->uc.tuc_flags);
4765 __put_user((abi_ulong)0, (abi_ulong *)&frame->uc.tuc_link);
4766 __put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp);
4767 __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
4768 &frame->uc.tuc_stack.ss_flags);
4769 __put_user(target_sigaltstack_used.ss_size, &frame->uc.tuc_stack.ss_size);
4770 save_sigregs(env, &frame->uc.tuc_mcontext);
4771 for (i = 0; i < TARGET_NSIG_WORDS; i++) {
4772 __put_user((abi_ulong)set->sig[i],
4773 (abi_ulong *)&frame->uc.tuc_sigmask.sig[i]);
4774 }
4775
4776 /* Set up to return from userspace. If provided, use a stub
4777 already in userspace. */
4778 if (ka->sa_flags & TARGET_SA_RESTORER) {
4779 env->regs[14] = (unsigned long) ka->sa_restorer | PSW_ADDR_AMODE;
4780 } else {
4781 env->regs[14] = (unsigned long) frame->retcode | PSW_ADDR_AMODE;
4782 __put_user(S390_SYSCALL_OPCODE | TARGET_NR_rt_sigreturn,
4783 (uint16_t *)(frame->retcode));
4784 }
4785
4786 /* Set up backchain. */
4787 __put_user(env->regs[15], (abi_ulong *) frame);
4788
4789 /* Set up registers for signal handler */
4790 env->regs[15] = frame_addr;
4791 env->psw.addr = (target_ulong) ka->_sa_handler | PSW_ADDR_AMODE;
4792
4793 env->regs[2] = sig; //map_signal(sig);
4794 env->regs[3] = frame_addr + offsetof(typeof(*frame), info);
4795 env->regs[4] = frame_addr + offsetof(typeof(*frame), uc);
4796 return;
4797
4798 give_sigsegv:
4799 force_sigsegv(sig);
4800 }
4801
4802 static int
4803 restore_sigregs(CPUS390XState *env, target_sigregs *sc)
4804 {
4805 int err = 0;
4806 int i;
4807
4808 for (i = 0; i < 16; i++) {
4809 __get_user(env->regs[i], &sc->regs.gprs[i]);
4810 }
4811
4812 __get_user(env->psw.mask, &sc->regs.psw.mask);
4813 trace_user_s390x_restore_sigregs(env, (unsigned long long)sc->regs.psw.addr,
4814 (unsigned long long)env->psw.addr);
4815 __get_user(env->psw.addr, &sc->regs.psw.addr);
4816 /* FIXME: 31-bit -> | PSW_ADDR_AMODE */
4817
4818 for (i = 0; i < 16; i++) {
4819 __get_user(env->aregs[i], &sc->regs.acrs[i]);
4820 }
4821 for (i = 0; i < 16; i++) {
4822 __get_user(get_freg(env, i)->ll, &sc->fpregs.fprs[i]);
4823 }
4824
4825 return err;
4826 }
4827
4828 long do_sigreturn(CPUS390XState *env)
4829 {
4830 sigframe *frame;
4831 abi_ulong frame_addr = env->regs[15];
4832 target_sigset_t target_set;
4833 sigset_t set;
4834
4835 trace_user_do_sigreturn(env, frame_addr);
4836 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
4837 goto badframe;
4838 }
4839 __get_user(target_set.sig[0], &frame->sc.oldmask[0]);
4840
4841 target_to_host_sigset_internal(&set, &target_set);
4842 set_sigmask(&set); /* ~_BLOCKABLE? */
4843
4844 if (restore_sigregs(env, &frame->sregs)) {
4845 goto badframe;
4846 }
4847
4848 unlock_user_struct(frame, frame_addr, 0);
4849 return -TARGET_QEMU_ESIGRETURN;
4850
4851 badframe:
4852 force_sig(TARGET_SIGSEGV);
4853 return -TARGET_QEMU_ESIGRETURN;
4854 }
4855
4856 long do_rt_sigreturn(CPUS390XState *env)
4857 {
4858 rt_sigframe *frame;
4859 abi_ulong frame_addr = env->regs[15];
4860 sigset_t set;
4861
4862 trace_user_do_rt_sigreturn(env, frame_addr);
4863 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
4864 goto badframe;
4865 }
4866 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
4867
4868 set_sigmask(&set); /* ~_BLOCKABLE? */
4869
4870 if (restore_sigregs(env, &frame->uc.tuc_mcontext)) {
4871 goto badframe;
4872 }
4873
4874 if (do_sigaltstack(frame_addr + offsetof(rt_sigframe, uc.tuc_stack), 0,
4875 get_sp_from_cpustate(env)) == -EFAULT) {
4876 goto badframe;
4877 }
4878 unlock_user_struct(frame, frame_addr, 0);
4879 return -TARGET_QEMU_ESIGRETURN;
4880
4881 badframe:
4882 unlock_user_struct(frame, frame_addr, 0);
4883 force_sig(TARGET_SIGSEGV);
4884 return -TARGET_QEMU_ESIGRETURN;
4885 }
4886
4887 #elif defined(TARGET_PPC)
4888
4889 /* Size of dummy stack frame allocated when calling signal handler.
4890 See arch/powerpc/include/asm/ptrace.h. */
4891 #if defined(TARGET_PPC64)
4892 #define SIGNAL_FRAMESIZE 128
4893 #else
4894 #define SIGNAL_FRAMESIZE 64
4895 #endif
4896
4897 /* See arch/powerpc/include/asm/ucontext.h. Only used for 32-bit PPC;
4898 on 64-bit PPC, sigcontext and mcontext are one and the same. */
4899 struct target_mcontext {
4900 target_ulong mc_gregs[48];
4901 /* Includes fpscr. */
4902 uint64_t mc_fregs[33];
4903 #if defined(TARGET_PPC64)
4904 /* Pointer to the vector regs */
4905 target_ulong v_regs;
4906 #else
4907 target_ulong mc_pad[2];
4908 #endif
4909 /* We need to handle Altivec and SPE at the same time, which no
4910 kernel needs to do. Fortunately, the kernel defines this bit to
4911 be Altivec-register-large all the time, rather than trying to
4912 twiddle it based on the specific platform. */
4913 union {
4914 /* SPE vector registers. One extra for SPEFSCR. */
4915 uint32_t spe[33];
4916 /* Altivec vector registers. The packing of VSCR and VRSAVE
4917 varies depending on whether we're PPC64 or not: PPC64 splits
4918 them apart; PPC32 stuffs them together.
4919 We also need to account for the VSX registers on PPC64
4920 */
4921 #if defined(TARGET_PPC64)
4922 #define QEMU_NVRREG (34 + 16)
4923 /* On ppc64, this mcontext structure is naturally *unaligned*,
4924 * or rather it is aligned on a 8 bytes boundary but not on
4925 * a 16 bytes one. This pad fixes it up. This is also why the
4926 * vector regs are referenced by the v_regs pointer above so
4927 * any amount of padding can be added here
4928 */
4929 target_ulong pad;
4930 #else
4931 /* On ppc32, we are already aligned to 16 bytes */
4932 #define QEMU_NVRREG 33
4933 #endif
4934 /* We cannot use ppc_avr_t here as we do *not* want the implied
4935 * 16-bytes alignment that would result from it. This would have
4936 * the effect of making the whole struct target_mcontext aligned
4937 * which breaks the layout of struct target_ucontext on ppc64.
4938 */
4939 uint64_t altivec[QEMU_NVRREG][2];
4940 #undef QEMU_NVRREG
4941 } mc_vregs;
4942 };
4943
4944 /* See arch/powerpc/include/asm/sigcontext.h. */
4945 struct target_sigcontext {
4946 target_ulong _unused[4];
4947 int32_t signal;
4948 #if defined(TARGET_PPC64)
4949 int32_t pad0;
4950 #endif
4951 target_ulong handler;
4952 target_ulong oldmask;
4953 target_ulong regs; /* struct pt_regs __user * */
4954 #if defined(TARGET_PPC64)
4955 struct target_mcontext mcontext;
4956 #endif
4957 };
4958
4959 /* Indices for target_mcontext.mc_gregs, below.
4960 See arch/powerpc/include/asm/ptrace.h for details. */
4961 enum {
4962 TARGET_PT_R0 = 0,
4963 TARGET_PT_R1 = 1,
4964 TARGET_PT_R2 = 2,
4965 TARGET_PT_R3 = 3,
4966 TARGET_PT_R4 = 4,
4967 TARGET_PT_R5 = 5,
4968 TARGET_PT_R6 = 6,
4969 TARGET_PT_R7 = 7,
4970 TARGET_PT_R8 = 8,
4971 TARGET_PT_R9 = 9,
4972 TARGET_PT_R10 = 10,
4973 TARGET_PT_R11 = 11,
4974 TARGET_PT_R12 = 12,
4975 TARGET_PT_R13 = 13,
4976 TARGET_PT_R14 = 14,
4977 TARGET_PT_R15 = 15,
4978 TARGET_PT_R16 = 16,
4979 TARGET_PT_R17 = 17,
4980 TARGET_PT_R18 = 18,
4981 TARGET_PT_R19 = 19,
4982 TARGET_PT_R20 = 20,
4983 TARGET_PT_R21 = 21,
4984 TARGET_PT_R22 = 22,
4985 TARGET_PT_R23 = 23,
4986 TARGET_PT_R24 = 24,
4987 TARGET_PT_R25 = 25,
4988 TARGET_PT_R26 = 26,
4989 TARGET_PT_R27 = 27,
4990 TARGET_PT_R28 = 28,
4991 TARGET_PT_R29 = 29,
4992 TARGET_PT_R30 = 30,
4993 TARGET_PT_R31 = 31,
4994 TARGET_PT_NIP = 32,
4995 TARGET_PT_MSR = 33,
4996 TARGET_PT_ORIG_R3 = 34,
4997 TARGET_PT_CTR = 35,
4998 TARGET_PT_LNK = 36,
4999 TARGET_PT_XER = 37,
5000 TARGET_PT_CCR = 38,
5001 /* Yes, there are two registers with #39. One is 64-bit only. */
5002 TARGET_PT_MQ = 39,
5003 TARGET_PT_SOFTE = 39,
5004 TARGET_PT_TRAP = 40,
5005 TARGET_PT_DAR = 41,
5006 TARGET_PT_DSISR = 42,
5007 TARGET_PT_RESULT = 43,
5008 TARGET_PT_REGS_COUNT = 44
5009 };
5010
5011
5012 struct target_ucontext {
5013 target_ulong tuc_flags;
5014 target_ulong tuc_link; /* ucontext_t __user * */
5015 struct target_sigaltstack tuc_stack;
5016 #if !defined(TARGET_PPC64)
5017 int32_t tuc_pad[7];
5018 target_ulong tuc_regs; /* struct mcontext __user *
5019 points to uc_mcontext field */
5020 #endif
5021 target_sigset_t tuc_sigmask;
5022 #if defined(TARGET_PPC64)
5023 target_sigset_t unused[15]; /* Allow for uc_sigmask growth */
5024 struct target_sigcontext tuc_sigcontext;
5025 #else
5026 int32_t tuc_maskext[30];
5027 int32_t tuc_pad2[3];
5028 struct target_mcontext tuc_mcontext;
5029 #endif
5030 };
5031
5032 /* See arch/powerpc/kernel/signal_32.c. */
5033 struct target_sigframe {
5034 struct target_sigcontext sctx;
5035 struct target_mcontext mctx;
5036 int32_t abigap[56];
5037 };
5038
5039 #if defined(TARGET_PPC64)
5040
5041 #define TARGET_TRAMP_SIZE 6
5042
5043 struct target_rt_sigframe {
5044 /* sys_rt_sigreturn requires the ucontext be the first field */
5045 struct target_ucontext uc;
5046 target_ulong _unused[2];
5047 uint32_t trampoline[TARGET_TRAMP_SIZE];
5048 target_ulong pinfo; /* struct siginfo __user * */
5049 target_ulong puc; /* void __user * */
5050 struct target_siginfo info;
5051 /* 64 bit ABI allows for 288 bytes below sp before decrementing it. */
5052 char abigap[288];
5053 } __attribute__((aligned(16)));
5054
5055 #else
5056
5057 struct target_rt_sigframe {
5058 struct target_siginfo info;
5059 struct target_ucontext uc;
5060 int32_t abigap[56];
5061 };
5062
5063 #endif
5064
5065 #if defined(TARGET_PPC64)
5066
5067 struct target_func_ptr {
5068 target_ulong entry;
5069 target_ulong toc;
5070 };
5071
5072 #endif
5073
5074 /* We use the mc_pad field for the signal return trampoline. */
5075 #define tramp mc_pad
5076
5077 /* See arch/powerpc/kernel/signal.c. */
5078 static target_ulong get_sigframe(struct target_sigaction *ka,
5079 CPUPPCState *env,
5080 int frame_size)
5081 {
5082 target_ulong oldsp;
5083
5084 oldsp = env->gpr[1];
5085
5086 if ((ka->sa_flags & TARGET_SA_ONSTACK) &&
5087 (sas_ss_flags(oldsp) == 0)) {
5088 oldsp = (target_sigaltstack_used.ss_sp
5089 + target_sigaltstack_used.ss_size);
5090 }
5091
5092 return (oldsp - frame_size) & ~0xFUL;
5093 }
5094
5095 #if ((defined(TARGET_WORDS_BIGENDIAN) && defined(HOST_WORDS_BIGENDIAN)) || \
5096 (!defined(HOST_WORDS_BIGENDIAN) && !defined(TARGET_WORDS_BIGENDIAN)))
5097 #define PPC_VEC_HI 0
5098 #define PPC_VEC_LO 1
5099 #else
5100 #define PPC_VEC_HI 1
5101 #define PPC_VEC_LO 0
5102 #endif
5103
5104
5105 static void save_user_regs(CPUPPCState *env, struct target_mcontext *frame)
5106 {
5107 target_ulong msr = env->msr;
5108 int i;
5109 target_ulong ccr = 0;
5110
5111 /* In general, the kernel attempts to be intelligent about what it
5112 needs to save for Altivec/FP/SPE registers. We don't care that
5113 much, so we just go ahead and save everything. */
5114
5115 /* Save general registers. */
5116 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
5117 __put_user(env->gpr[i], &frame->mc_gregs[i]);
5118 }
5119 __put_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP]);
5120 __put_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR]);
5121 __put_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK]);
5122 __put_user(env->xer, &frame->mc_gregs[TARGET_PT_XER]);
5123
5124 for (i = 0; i < ARRAY_SIZE(env->crf); i++) {
5125 ccr |= env->crf[i] << (32 - ((i + 1) * 4));
5126 }
5127 __put_user(ccr, &frame->mc_gregs[TARGET_PT_CCR]);
5128
5129 /* Save Altivec registers if necessary. */
5130 if (env->insns_flags & PPC_ALTIVEC) {
5131 uint32_t *vrsave;
5132 for (i = 0; i < ARRAY_SIZE(env->avr); i++) {
5133 ppc_avr_t *avr = &env->avr[i];
5134 ppc_avr_t *vreg = (ppc_avr_t *)&frame->mc_vregs.altivec[i];
5135
5136 __put_user(avr->u64[PPC_VEC_HI], &vreg->u64[0]);
5137 __put_user(avr->u64[PPC_VEC_LO], &vreg->u64[1]);
5138 }
5139 /* Set MSR_VR in the saved MSR value to indicate that
5140 frame->mc_vregs contains valid data. */
5141 msr |= MSR_VR;
5142 #if defined(TARGET_PPC64)
5143 vrsave = (uint32_t *)&frame->mc_vregs.altivec[33];
5144 /* 64-bit needs to put a pointer to the vectors in the frame */
5145 __put_user(h2g(frame->mc_vregs.altivec), &frame->v_regs);
5146 #else
5147 vrsave = (uint32_t *)&frame->mc_vregs.altivec[32];
5148 #endif
5149 __put_user((uint32_t)env->spr[SPR_VRSAVE], vrsave);
5150 }
5151
5152 /* Save VSX second halves */
5153 if (env->insns_flags2 & PPC2_VSX) {
5154 uint64_t *vsregs = (uint64_t *)&frame->mc_vregs.altivec[34];
5155 for (i = 0; i < ARRAY_SIZE(env->vsr); i++) {
5156 __put_user(env->vsr[i], &vsregs[i]);
5157 }
5158 }
5159
5160 /* Save floating point registers. */
5161 if (env->insns_flags & PPC_FLOAT) {
5162 for (i = 0; i < ARRAY_SIZE(env->fpr); i++) {
5163 __put_user(env->fpr[i], &frame->mc_fregs[i]);
5164 }
5165 __put_user((uint64_t) env->fpscr, &frame->mc_fregs[32]);
5166 }
5167
5168 /* Save SPE registers. The kernel only saves the high half. */
5169 if (env->insns_flags & PPC_SPE) {
5170 #if defined(TARGET_PPC64)
5171 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
5172 __put_user(env->gpr[i] >> 32, &frame->mc_vregs.spe[i]);
5173 }
5174 #else
5175 for (i = 0; i < ARRAY_SIZE(env->gprh); i++) {
5176 __put_user(env->gprh[i], &frame->mc_vregs.spe[i]);
5177 }
5178 #endif
5179 /* Set MSR_SPE in the saved MSR value to indicate that
5180 frame->mc_vregs contains valid data. */
5181 msr |= MSR_SPE;
5182 __put_user(env->spe_fscr, &frame->mc_vregs.spe[32]);
5183 }
5184
5185 /* Store MSR. */
5186 __put_user(msr, &frame->mc_gregs[TARGET_PT_MSR]);
5187 }
5188
5189 static void encode_trampoline(int sigret, uint32_t *tramp)
5190 {
5191 /* Set up the sigreturn trampoline: li r0,sigret; sc. */
5192 if (sigret) {
5193 __put_user(0x38000000 | sigret, &tramp[0]);
5194 __put_user(0x44000002, &tramp[1]);
5195 }
5196 }
5197
5198 static void restore_user_regs(CPUPPCState *env,
5199 struct target_mcontext *frame, int sig)
5200 {
5201 target_ulong save_r2 = 0;
5202 target_ulong msr;
5203 target_ulong ccr;
5204
5205 int i;
5206
5207 if (!sig) {
5208 save_r2 = env->gpr[2];
5209 }
5210
5211 /* Restore general registers. */
5212 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
5213 __get_user(env->gpr[i], &frame->mc_gregs[i]);
5214 }
5215 __get_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP]);
5216 __get_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR]);
5217 __get_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK]);
5218 __get_user(env->xer, &frame->mc_gregs[TARGET_PT_XER]);
5219 __get_user(ccr, &frame->mc_gregs[TARGET_PT_CCR]);
5220
5221 for (i = 0; i < ARRAY_SIZE(env->crf); i++) {
5222 env->crf[i] = (ccr >> (32 - ((i + 1) * 4))) & 0xf;
5223 }
5224
5225 if (!sig) {
5226 env->gpr[2] = save_r2;
5227 }
5228 /* Restore MSR. */
5229 __get_user(msr, &frame->mc_gregs[TARGET_PT_MSR]);
5230
5231 /* If doing signal return, restore the previous little-endian mode. */
5232 if (sig)
5233 env->msr = (env->msr & ~(1ull << MSR_LE)) | (msr & (1ull << MSR_LE));
5234
5235 /* Restore Altivec registers if necessary. */
5236 if (env->insns_flags & PPC_ALTIVEC) {
5237 ppc_avr_t *v_regs;
5238 uint32_t *vrsave;
5239 #if defined(TARGET_PPC64)
5240 uint64_t v_addr;
5241 /* 64-bit needs to recover the pointer to the vectors from the frame */
5242 __get_user(v_addr, &frame->v_regs);
5243 v_regs = g2h(v_addr);
5244 #else
5245 v_regs = (ppc_avr_t *)frame->mc_vregs.altivec;
5246 #endif
5247 for (i = 0; i < ARRAY_SIZE(env->avr); i++) {
5248 ppc_avr_t *avr = &env->avr[i];
5249 ppc_avr_t *vreg = &v_regs[i];
5250
5251 __get_user(avr->u64[PPC_VEC_HI], &vreg->u64[0]);
5252 __get_user(avr->u64[PPC_VEC_LO], &vreg->u64[1]);
5253 }
5254 /* Set MSR_VEC in the saved MSR value to indicate that
5255 frame->mc_vregs contains valid data. */
5256 #if defined(TARGET_PPC64)
5257 vrsave = (uint32_t *)&v_regs[33];
5258 #else
5259 vrsave = (uint32_t *)&v_regs[32];
5260 #endif
5261 __get_user(env->spr[SPR_VRSAVE], vrsave);
5262 }
5263
5264 /* Restore VSX second halves */
5265 if (env->insns_flags2 & PPC2_VSX) {
5266 uint64_t *vsregs = (uint64_t *)&frame->mc_vregs.altivec[34];
5267 for (i = 0; i < ARRAY_SIZE(env->vsr); i++) {
5268 __get_user(env->vsr[i], &vsregs[i]);
5269 }
5270 }
5271
5272 /* Restore floating point registers. */
5273 if (env->insns_flags & PPC_FLOAT) {
5274 uint64_t fpscr;
5275 for (i = 0; i < ARRAY_SIZE(env->fpr); i++) {
5276 __get_user(env->fpr[i], &frame->mc_fregs[i]);
5277 }
5278 __get_user(fpscr, &frame->mc_fregs[32]);
5279 env->fpscr = (uint32_t) fpscr;
5280 }
5281
5282 /* Save SPE registers. The kernel only saves the high half. */
5283 if (env->insns_flags & PPC_SPE) {
5284 #if defined(TARGET_PPC64)
5285 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
5286 uint32_t hi;
5287
5288 __get_user(hi, &frame->mc_vregs.spe[i]);
5289 env->gpr[i] = ((uint64_t)hi << 32) | ((uint32_t) env->gpr[i]);
5290 }
5291 #else
5292 for (i = 0; i < ARRAY_SIZE(env->gprh); i++) {
5293 __get_user(env->gprh[i], &frame->mc_vregs.spe[i]);
5294 }
5295 #endif
5296 __get_user(env->spe_fscr, &frame->mc_vregs.spe[32]);
5297 }
5298 }
5299
5300 #if !defined(TARGET_PPC64)
5301 static void setup_frame(int sig, struct target_sigaction *ka,
5302 target_sigset_t *set, CPUPPCState *env)
5303 {
5304 struct target_sigframe *frame;
5305 struct target_sigcontext *sc;
5306 target_ulong frame_addr, newsp;
5307 int err = 0;
5308
5309 frame_addr = get_sigframe(ka, env, sizeof(*frame));
5310 trace_user_setup_frame(env, frame_addr);
5311 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
5312 goto sigsegv;
5313 sc = &frame->sctx;
5314
5315 __put_user(ka->_sa_handler, &sc->handler);
5316 __put_user(set->sig[0], &sc->oldmask);
5317 __put_user(set->sig[1], &sc->_unused[3]);
5318 __put_user(h2g(&frame->mctx), &sc->regs);
5319 __put_user(sig, &sc->signal);
5320
5321 /* Save user regs. */
5322 save_user_regs(env, &frame->mctx);
5323
5324 /* Construct the trampoline code on the stack. */
5325 encode_trampoline(TARGET_NR_sigreturn, (uint32_t *)&frame->mctx.tramp);
5326
5327 /* The kernel checks for the presence of a VDSO here. We don't
5328 emulate a vdso, so use a sigreturn system call. */
5329 env->lr = (target_ulong) h2g(frame->mctx.tramp);
5330
5331 /* Turn off all fp exceptions. */
5332 env->fpscr = 0;
5333
5334 /* Create a stack frame for the caller of the handler. */
5335 newsp = frame_addr - SIGNAL_FRAMESIZE;
5336 err |= put_user(env->gpr[1], newsp, target_ulong);
5337
5338 if (err)
5339 goto sigsegv;
5340
5341 /* Set up registers for signal handler. */
5342 env->gpr[1] = newsp;
5343 env->gpr[3] = sig;
5344 env->gpr[4] = frame_addr + offsetof(struct target_sigframe, sctx);
5345
5346 env->nip = (target_ulong) ka->_sa_handler;
5347
5348 /* Signal handlers are entered in big-endian mode. */
5349 env->msr &= ~(1ull << MSR_LE);
5350
5351 unlock_user_struct(frame, frame_addr, 1);
5352 return;
5353
5354 sigsegv:
5355 unlock_user_struct(frame, frame_addr, 1);
5356 force_sigsegv(sig);
5357 }
5358 #endif /* !defined(TARGET_PPC64) */
5359
5360 static void setup_rt_frame(int sig, struct target_sigaction *ka,
5361 target_siginfo_t *info,
5362 target_sigset_t *set, CPUPPCState *env)
5363 {
5364 struct target_rt_sigframe *rt_sf;
5365 uint32_t *trampptr = 0;
5366 struct target_mcontext *mctx = 0;
5367 target_ulong rt_sf_addr, newsp = 0;
5368 int i, err = 0;
5369 #if defined(TARGET_PPC64)
5370 struct target_sigcontext *sc = 0;
5371 struct image_info *image = ((TaskState *)thread_cpu->opaque)->info;
5372 #endif
5373
5374 rt_sf_addr = get_sigframe(ka, env, sizeof(*rt_sf));
5375 if (!lock_user_struct(VERIFY_WRITE, rt_sf, rt_sf_addr, 1))
5376 goto sigsegv;
5377
5378 tswap_siginfo(&rt_sf->info, info);
5379
5380 __put_user(0, &rt_sf->uc.tuc_flags);
5381 __put_user(0, &rt_sf->uc.tuc_link);
5382 __put_user((target_ulong)target_sigaltstack_used.ss_sp,
5383 &rt_sf->uc.tuc_stack.ss_sp);
5384 __put_user(sas_ss_flags(env->gpr[1]),
5385 &rt_sf->uc.tuc_stack.ss_flags);
5386 __put_user(target_sigaltstack_used.ss_size,
5387 &rt_sf->uc.tuc_stack.ss_size);
5388 #if !defined(TARGET_PPC64)
5389 __put_user(h2g (&rt_sf->uc.tuc_mcontext),
5390 &rt_sf->uc.tuc_regs);
5391 #endif
5392 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
5393 __put_user(set->sig[i], &rt_sf->uc.tuc_sigmask.sig[i]);
5394 }
5395
5396 #if defined(TARGET_PPC64)
5397 mctx = &rt_sf->uc.tuc_sigcontext.mcontext;
5398 trampptr = &rt_sf->trampoline[0];
5399
5400 sc = &rt_sf->uc.tuc_sigcontext;
5401 __put_user(h2g(mctx), &sc->regs);
5402 __put_user(sig, &sc->signal);
5403 #else
5404 mctx = &rt_sf->uc.tuc_mcontext;
5405 trampptr = (uint32_t *)&rt_sf->uc.tuc_mcontext.tramp;
5406 #endif
5407
5408 save_user_regs(env, mctx);
5409 encode_trampoline(TARGET_NR_rt_sigreturn, trampptr);
5410
5411 /* The kernel checks for the presence of a VDSO here. We don't
5412 emulate a vdso, so use a sigreturn system call. */
5413 env->lr = (target_ulong) h2g(trampptr);
5414
5415 /* Turn off all fp exceptions. */
5416 env->fpscr = 0;
5417
5418 /* Create a stack frame for the caller of the handler. */
5419 newsp = rt_sf_addr - (SIGNAL_FRAMESIZE + 16);
5420 err |= put_user(env->gpr[1], newsp, target_ulong);
5421
5422 if (err)
5423 goto sigsegv;
5424
5425 /* Set up registers for signal handler. */
5426 env->gpr[1] = newsp;
5427 env->gpr[3] = (target_ulong) sig;
5428 env->gpr[4] = (target_ulong) h2g(&rt_sf->info);
5429 env->gpr[5] = (target_ulong) h2g(&rt_sf->uc);
5430 env->gpr[6] = (target_ulong) h2g(rt_sf);
5431
5432 #if defined(TARGET_PPC64)
5433 if (get_ppc64_abi(image) < 2) {
5434 /* ELFv1 PPC64 function pointers are pointers to OPD entries. */
5435 struct target_func_ptr *handler =
5436 (struct target_func_ptr *)g2h(ka->_sa_handler);
5437 env->nip = tswapl(handler->entry);
5438 env->gpr[2] = tswapl(handler->toc);
5439 } else {
5440 /* ELFv2 PPC64 function pointers are entry points, but R12
5441 * must also be set */
5442 env->nip = tswapl((target_ulong) ka->_sa_handler);
5443 env->gpr[12] = env->nip;
5444 }
5445 #else
5446 env->nip = (target_ulong) ka->_sa_handler;
5447 #endif
5448
5449 /* Signal handlers are entered in big-endian mode. */
5450 env->msr &= ~(1ull << MSR_LE);
5451
5452 unlock_user_struct(rt_sf, rt_sf_addr, 1);
5453 return;
5454
5455 sigsegv:
5456 unlock_user_struct(rt_sf, rt_sf_addr, 1);
5457 force_sigsegv(sig);
5458
5459 }
5460
5461 #if !defined(TARGET_PPC64)
5462 long do_sigreturn(CPUPPCState *env)
5463 {
5464 struct target_sigcontext *sc = NULL;
5465 struct target_mcontext *sr = NULL;
5466 target_ulong sr_addr = 0, sc_addr;
5467 sigset_t blocked;
5468 target_sigset_t set;
5469
5470 sc_addr = env->gpr[1] + SIGNAL_FRAMESIZE;
5471 if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1))
5472 goto sigsegv;
5473
5474 #if defined(TARGET_PPC64)
5475 set.sig[0] = sc->oldmask + ((uint64_t)(sc->_unused[3]) << 32);
5476 #else
5477 __get_user(set.sig[0], &sc->oldmask);
5478 __get_user(set.sig[1], &sc->_unused[3]);
5479 #endif
5480 target_to_host_sigset_internal(&blocked, &set);
5481 set_sigmask(&blocked);
5482
5483 __get_user(sr_addr, &sc->regs);
5484 if (!lock_user_struct(VERIFY_READ, sr, sr_addr, 1))
5485 goto sigsegv;
5486 restore_user_regs(env, sr, 1);
5487
5488 unlock_user_struct(sr, sr_addr, 1);
5489 unlock_user_struct(sc, sc_addr, 1);
5490 return -TARGET_QEMU_ESIGRETURN;
5491
5492 sigsegv:
5493 unlock_user_struct(sr, sr_addr, 1);
5494 unlock_user_struct(sc, sc_addr, 1);
5495 force_sig(TARGET_SIGSEGV);
5496 return -TARGET_QEMU_ESIGRETURN;
5497 }
5498 #endif /* !defined(TARGET_PPC64) */
5499
5500 /* See arch/powerpc/kernel/signal_32.c. */
5501 static int do_setcontext(struct target_ucontext *ucp, CPUPPCState *env, int sig)
5502 {
5503 struct target_mcontext *mcp;
5504 target_ulong mcp_addr;
5505 sigset_t blocked;
5506 target_sigset_t set;
5507
5508 if (copy_from_user(&set, h2g(ucp) + offsetof(struct target_ucontext, tuc_sigmask),
5509 sizeof (set)))
5510 return 1;
5511
5512 #if defined(TARGET_PPC64)
5513 mcp_addr = h2g(ucp) +
5514 offsetof(struct target_ucontext, tuc_sigcontext.mcontext);
5515 #else
5516 __get_user(mcp_addr, &ucp->tuc_regs);
5517 #endif
5518
5519 if (!lock_user_struct(VERIFY_READ, mcp, mcp_addr, 1))
5520 return 1;
5521
5522 target_to_host_sigset_internal(&blocked, &set);
5523 set_sigmask(&blocked);
5524 restore_user_regs(env, mcp, sig);
5525
5526 unlock_user_struct(mcp, mcp_addr, 1);
5527 return 0;
5528 }
5529
5530 long do_rt_sigreturn(CPUPPCState *env)
5531 {
5532 struct target_rt_sigframe *rt_sf = NULL;
5533 target_ulong rt_sf_addr;
5534
5535 rt_sf_addr = env->gpr[1] + SIGNAL_FRAMESIZE + 16;
5536 if (!lock_user_struct(VERIFY_READ, rt_sf, rt_sf_addr, 1))
5537 goto sigsegv;
5538
5539 if (do_setcontext(&rt_sf->uc, env, 1))
5540 goto sigsegv;
5541
5542 do_sigaltstack(rt_sf_addr
5543 + offsetof(struct target_rt_sigframe, uc.tuc_stack),
5544 0, env->gpr[1]);
5545
5546 unlock_user_struct(rt_sf, rt_sf_addr, 1);
5547 return -TARGET_QEMU_ESIGRETURN;
5548
5549 sigsegv:
5550 unlock_user_struct(rt_sf, rt_sf_addr, 1);
5551 force_sig(TARGET_SIGSEGV);
5552 return -TARGET_QEMU_ESIGRETURN;
5553 }
5554
5555 #elif defined(TARGET_M68K)
5556
5557 struct target_sigcontext {
5558 abi_ulong sc_mask;
5559 abi_ulong sc_usp;
5560 abi_ulong sc_d0;
5561 abi_ulong sc_d1;
5562 abi_ulong sc_a0;
5563 abi_ulong sc_a1;
5564 unsigned short sc_sr;
5565 abi_ulong sc_pc;
5566 };
5567
5568 struct target_sigframe
5569 {
5570 abi_ulong pretcode;
5571 int sig;
5572 int code;
5573 abi_ulong psc;
5574 char retcode[8];
5575 abi_ulong extramask[TARGET_NSIG_WORDS-1];
5576 struct target_sigcontext sc;
5577 };
5578
5579 typedef int target_greg_t;
5580 #define TARGET_NGREG 18
5581 typedef target_greg_t target_gregset_t[TARGET_NGREG];
5582
5583 typedef struct target_fpregset {
5584 int f_fpcntl[3];
5585 int f_fpregs[8*3];
5586 } target_fpregset_t;
5587
5588 struct target_mcontext {
5589 int version;
5590 target_gregset_t gregs;
5591 target_fpregset_t fpregs;
5592 };
5593
5594 #define TARGET_MCONTEXT_VERSION 2
5595
5596 struct target_ucontext {
5597 abi_ulong tuc_flags;
5598 abi_ulong tuc_link;
5599 target_stack_t tuc_stack;
5600 struct target_mcontext tuc_mcontext;
5601 abi_long tuc_filler[80];
5602 target_sigset_t tuc_sigmask;
5603 };
5604
5605 struct target_rt_sigframe
5606 {
5607 abi_ulong pretcode;
5608 int sig;
5609 abi_ulong pinfo;
5610 abi_ulong puc;
5611 char retcode[8];
5612 struct target_siginfo info;
5613 struct target_ucontext uc;
5614 };
5615
5616 static void setup_sigcontext(struct target_sigcontext *sc, CPUM68KState *env,
5617 abi_ulong mask)
5618 {
5619 uint32_t sr = (env->sr & 0xff00) | cpu_m68k_get_ccr(env);
5620 __put_user(mask, &sc->sc_mask);
5621 __put_user(env->aregs[7], &sc->sc_usp);
5622 __put_user(env->dregs[0], &sc->sc_d0);
5623 __put_user(env->dregs[1], &sc->sc_d1);
5624 __put_user(env->aregs[0], &sc->sc_a0);
5625 __put_user(env->aregs[1], &sc->sc_a1);
5626 __put_user(sr, &sc->sc_sr);
5627 __put_user(env->pc, &sc->sc_pc);
5628 }
5629
5630 static void
5631 restore_sigcontext(CPUM68KState *env, struct target_sigcontext *sc)
5632 {
5633 int temp;
5634
5635 __get_user(env->aregs[7], &sc->sc_usp);
5636 __get_user(env->dregs[0], &sc->sc_d0);
5637 __get_user(env->dregs[1], &sc->sc_d1);
5638 __get_user(env->aregs[0], &sc->sc_a0);
5639 __get_user(env->aregs[1], &sc->sc_a1);
5640 __get_user(env->pc, &sc->sc_pc);
5641 __get_user(temp, &sc->sc_sr);
5642 cpu_m68k_set_ccr(env, temp);
5643 }
5644
5645 /*
5646 * Determine which stack to use..
5647 */
5648 static inline abi_ulong
5649 get_sigframe(struct target_sigaction *ka, CPUM68KState *regs,
5650 size_t frame_size)
5651 {
5652 unsigned long sp;
5653
5654 sp = regs->aregs[7];
5655
5656 /* This is the X/Open sanctioned signal stack switching. */
5657 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) {
5658 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
5659 }
5660
5661 return ((sp - frame_size) & -8UL);
5662 }
5663
5664 static void setup_frame(int sig, struct target_sigaction *ka,
5665 target_sigset_t *set, CPUM68KState *env)
5666 {
5667 struct target_sigframe *frame;
5668 abi_ulong frame_addr;
5669 abi_ulong retcode_addr;
5670 abi_ulong sc_addr;
5671 int i;
5672
5673 frame_addr = get_sigframe(ka, env, sizeof *frame);
5674 trace_user_setup_frame(env, frame_addr);
5675 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
5676 goto give_sigsegv;
5677 }
5678
5679 __put_user(sig, &frame->sig);
5680
5681 sc_addr = frame_addr + offsetof(struct target_sigframe, sc);
5682 __put_user(sc_addr, &frame->psc);
5683
5684 setup_sigcontext(&frame->sc, env, set->sig[0]);
5685
5686 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
5687 __put_user(set->sig[i], &frame->extramask[i - 1]);
5688 }
5689
5690 /* Set up to return from userspace. */
5691
5692 retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode);
5693 __put_user(retcode_addr, &frame->pretcode);
5694
5695 /* moveq #,d0; trap #0 */
5696
5697 __put_user(0x70004e40 + (TARGET_NR_sigreturn << 16),
5698 (uint32_t *)(frame->retcode));
5699
5700 /* Set up to return from userspace */
5701
5702 env->aregs[7] = frame_addr;
5703 env->pc = ka->_sa_handler;
5704
5705 unlock_user_struct(frame, frame_addr, 1);
5706 return;
5707
5708 give_sigsegv:
5709 force_sigsegv(sig);
5710 }
5711
5712 static inline void target_rt_save_fpu_state(struct target_ucontext *uc,
5713 CPUM68KState *env)
5714 {
5715 int i;
5716 target_fpregset_t *fpregs = &uc->tuc_mcontext.fpregs;
5717
5718 __put_user(env->fpcr, &fpregs->f_fpcntl[0]);
5719 __put_user(env->fpsr, &fpregs->f_fpcntl[1]);
5720 /* fpiar is not emulated */
5721
5722 for (i = 0; i < 8; i++) {
5723 uint32_t high = env->fregs[i].d.high << 16;
5724 __put_user(high, &fpregs->f_fpregs[i * 3]);
5725 __put_user(env->fregs[i].d.low,
5726 (uint64_t *)&fpregs->f_fpregs[i * 3 + 1]);
5727 }
5728 }
5729
5730 static inline int target_rt_setup_ucontext(struct target_ucontext *uc,
5731 CPUM68KState *env)
5732 {
5733 target_greg_t *gregs = uc->tuc_mcontext.gregs;
5734 uint32_t sr = (env->sr & 0xff00) | cpu_m68k_get_ccr(env);
5735
5736 __put_user(TARGET_MCONTEXT_VERSION, &uc->tuc_mcontext.version);
5737 __put_user(env->dregs[0], &gregs[0]);
5738 __put_user(env->dregs[1], &gregs[1]);
5739 __put_user(env->dregs[2], &gregs[2]);
5740 __put_user(env->dregs[3], &gregs[3]);
5741 __put_user(env->dregs[4], &gregs[4]);
5742 __put_user(env->dregs[5], &gregs[5]);
5743 __put_user(env->dregs[6], &gregs[6]);
5744 __put_user(env->dregs[7], &gregs[7]);
5745 __put_user(env->aregs[0], &gregs[8]);
5746 __put_user(env->aregs[1], &gregs[9]);
5747 __put_user(env->aregs[2], &gregs[10]);
5748 __put_user(env->aregs[3], &gregs[11]);
5749 __put_user(env->aregs[4], &gregs[12]);
5750 __put_user(env->aregs[5], &gregs[13]);
5751 __put_user(env->aregs[6], &gregs[14]);
5752 __put_user(env->aregs[7], &gregs[15]);
5753 __put_user(env->pc, &gregs[16]);
5754 __put_user(sr, &gregs[17]);
5755
5756 target_rt_save_fpu_state(uc, env);
5757
5758 return 0;
5759 }
5760
5761 static inline void target_rt_restore_fpu_state(CPUM68KState *env,
5762 struct target_ucontext *uc)
5763 {
5764 int i;
5765 target_fpregset_t *fpregs = &uc->tuc_mcontext.fpregs;
5766 uint32_t fpcr;
5767
5768 __get_user(fpcr, &fpregs->f_fpcntl[0]);
5769 cpu_m68k_set_fpcr(env, fpcr);
5770 __get_user(env->fpsr, &fpregs->f_fpcntl[1]);
5771 /* fpiar is not emulated */
5772
5773 for (i = 0; i < 8; i++) {
5774 uint32_t high;
5775 __get_user(high, &fpregs->f_fpregs[i * 3]);
5776 env->fregs[i].d.high = high >> 16;
5777 __get_user(env->fregs[i].d.low,
5778 (uint64_t *)&fpregs->f_fpregs[i * 3 + 1]);
5779 }
5780 }
5781
5782 static inline int target_rt_restore_ucontext(CPUM68KState *env,
5783 struct target_ucontext *uc)
5784 {
5785 int temp;
5786 target_greg_t *gregs = uc->tuc_mcontext.gregs;
5787
5788 __get_user(temp, &uc->tuc_mcontext.version);
5789 if (temp != TARGET_MCONTEXT_VERSION)
5790 goto badframe;
5791
5792 /* restore passed registers */
5793 __get_user(env->dregs[0], &gregs[0]);
5794 __get_user(env->dregs[1], &gregs[1]);
5795 __get_user(env->dregs[2], &gregs[2]);
5796 __get_user(env->dregs[3], &gregs[3]);
5797 __get_user(env->dregs[4], &gregs[4]);
5798 __get_user(env->dregs[5], &gregs[5]);
5799 __get_user(env->dregs[6], &gregs[6]);
5800 __get_user(env->dregs[7], &gregs[7]);
5801 __get_user(env->aregs[0], &gregs[8]);
5802 __get_user(env->aregs[1], &gregs[9]);
5803 __get_user(env->aregs[2], &gregs[10]);
5804 __get_user(env->aregs[3], &gregs[11]);
5805 __get_user(env->aregs[4], &gregs[12]);
5806 __get_user(env->aregs[5], &gregs[13]);
5807 __get_user(env->aregs[6], &gregs[14]);
5808 __get_user(env->aregs[7], &gregs[15]);
5809 __get_user(env->pc, &gregs[16]);
5810 __get_user(temp, &gregs[17]);
5811 cpu_m68k_set_ccr(env, temp);
5812
5813 target_rt_restore_fpu_state(env, uc);
5814
5815 return 0;
5816
5817 badframe:
5818 return 1;
5819 }
5820
5821 static void setup_rt_frame(int sig, struct target_sigaction *ka,
5822 target_siginfo_t *info,
5823 target_sigset_t *set, CPUM68KState *env)
5824 {
5825 struct target_rt_sigframe *frame;
5826 abi_ulong frame_addr;
5827 abi_ulong retcode_addr;
5828 abi_ulong info_addr;
5829 abi_ulong uc_addr;
5830 int err = 0;
5831 int i;
5832
5833 frame_addr = get_sigframe(ka, env, sizeof *frame);
5834 trace_user_setup_rt_frame(env, frame_addr);
5835 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
5836 goto give_sigsegv;
5837 }
5838
5839 __put_user(sig, &frame->sig);
5840
5841 info_addr = frame_addr + offsetof(struct target_rt_sigframe, info);
5842 __put_user(info_addr, &frame->pinfo);
5843
5844 uc_addr = frame_addr + offsetof(struct target_rt_sigframe, uc);
5845 __put_user(uc_addr, &frame->puc);
5846
5847 tswap_siginfo(&frame->info, info);
5848
5849 /* Create the ucontext */
5850
5851 __put_user(0, &frame->uc.tuc_flags);
5852 __put_user(0, &frame->uc.tuc_link);
5853 __put_user(target_sigaltstack_used.ss_sp,
5854 &frame->uc.tuc_stack.ss_sp);
5855 __put_user(sas_ss_flags(env->aregs[7]),
5856 &frame->uc.tuc_stack.ss_flags);
5857 __put_user(target_sigaltstack_used.ss_size,
5858 &frame->uc.tuc_stack.ss_size);
5859 err |= target_rt_setup_ucontext(&frame->uc, env);
5860
5861 if (err)
5862 goto give_sigsegv;
5863
5864 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
5865 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
5866 }
5867
5868 /* Set up to return from userspace. */
5869
5870 retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode);
5871 __put_user(retcode_addr, &frame->pretcode);
5872
5873 /* moveq #,d0; notb d0; trap #0 */
5874
5875 __put_user(0x70004600 + ((TARGET_NR_rt_sigreturn ^ 0xff) << 16),
5876 (uint32_t *)(frame->retcode + 0));
5877 __put_user(0x4e40, (uint16_t *)(frame->retcode + 4));
5878
5879 if (err)
5880 goto give_sigsegv;
5881
5882 /* Set up to return from userspace */
5883
5884 env->aregs[7] = frame_addr;
5885 env->pc = ka->_sa_handler;
5886
5887 unlock_user_struct(frame, frame_addr, 1);
5888 return;
5889
5890 give_sigsegv:
5891 unlock_user_struct(frame, frame_addr, 1);
5892 force_sigsegv(sig);
5893 }
5894
5895 long do_sigreturn(CPUM68KState *env)
5896 {
5897 struct target_sigframe *frame;
5898 abi_ulong frame_addr = env->aregs[7] - 4;
5899 target_sigset_t target_set;
5900 sigset_t set;
5901 int i;
5902
5903 trace_user_do_sigreturn(env, frame_addr);
5904 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
5905 goto badframe;
5906
5907 /* set blocked signals */
5908
5909 __get_user(target_set.sig[0], &frame->sc.sc_mask);
5910
5911 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
5912 __get_user(target_set.sig[i], &frame->extramask[i - 1]);
5913 }
5914
5915 target_to_host_sigset_internal(&set, &target_set);
5916 set_sigmask(&set);
5917
5918 /* restore registers */
5919
5920 restore_sigcontext(env, &frame->sc);
5921
5922 unlock_user_struct(frame, frame_addr, 0);
5923 return -TARGET_QEMU_ESIGRETURN;
5924
5925 badframe:
5926 force_sig(TARGET_SIGSEGV);
5927 return -TARGET_QEMU_ESIGRETURN;
5928 }
5929
5930 long do_rt_sigreturn(CPUM68KState *env)
5931 {
5932 struct target_rt_sigframe *frame;
5933 abi_ulong frame_addr = env->aregs[7] - 4;
5934 sigset_t set;
5935
5936 trace_user_do_rt_sigreturn(env, frame_addr);
5937 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
5938 goto badframe;
5939
5940 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
5941 set_sigmask(&set);
5942
5943 /* restore registers */
5944
5945 if (target_rt_restore_ucontext(env, &frame->uc))
5946 goto badframe;
5947
5948 if (do_sigaltstack(frame_addr +
5949 offsetof(struct target_rt_sigframe, uc.tuc_stack),
5950 0, get_sp_from_cpustate(env)) == -EFAULT)
5951 goto badframe;
5952
5953 unlock_user_struct(frame, frame_addr, 0);
5954 return -TARGET_QEMU_ESIGRETURN;
5955
5956 badframe:
5957 unlock_user_struct(frame, frame_addr, 0);
5958 force_sig(TARGET_SIGSEGV);
5959 return -TARGET_QEMU_ESIGRETURN;
5960 }
5961
5962 #elif defined(TARGET_ALPHA)
5963
5964 struct target_sigcontext {
5965 abi_long sc_onstack;
5966 abi_long sc_mask;
5967 abi_long sc_pc;
5968 abi_long sc_ps;
5969 abi_long sc_regs[32];
5970 abi_long sc_ownedfp;
5971 abi_long sc_fpregs[32];
5972 abi_ulong sc_fpcr;
5973 abi_ulong sc_fp_control;
5974 abi_ulong sc_reserved1;
5975 abi_ulong sc_reserved2;
5976 abi_ulong sc_ssize;
5977 abi_ulong sc_sbase;
5978 abi_ulong sc_traparg_a0;
5979 abi_ulong sc_traparg_a1;
5980 abi_ulong sc_traparg_a2;
5981 abi_ulong sc_fp_trap_pc;
5982 abi_ulong sc_fp_trigger_sum;
5983 abi_ulong sc_fp_trigger_inst;
5984 };
5985
5986 struct target_ucontext {
5987 abi_ulong tuc_flags;
5988 abi_ulong tuc_link;
5989 abi_ulong tuc_osf_sigmask;
5990 target_stack_t tuc_stack;
5991 struct target_sigcontext tuc_mcontext;
5992 target_sigset_t tuc_sigmask;
5993 };
5994
5995 struct target_sigframe {
5996 struct target_sigcontext sc;
5997 unsigned int retcode[3];
5998 };
5999
6000 struct target_rt_sigframe {
6001 target_siginfo_t info;
6002 struct target_ucontext uc;
6003 unsigned int retcode[3];
6004 };
6005
6006 #define INSN_MOV_R30_R16 0x47fe0410
6007 #define INSN_LDI_R0 0x201f0000
6008 #define INSN_CALLSYS 0x00000083
6009
6010 static void setup_sigcontext(struct target_sigcontext *sc, CPUAlphaState *env,
6011 abi_ulong frame_addr, target_sigset_t *set)
6012 {
6013 int i;
6014
6015 __put_user(on_sig_stack(frame_addr), &sc->sc_onstack);
6016 __put_user(set->sig[0], &sc->sc_mask);
6017 __put_user(env->pc, &sc->sc_pc);
6018 __put_user(8, &sc->sc_ps);
6019
6020 for (i = 0; i < 31; ++i) {
6021 __put_user(env->ir[i], &sc->sc_regs[i]);
6022 }
6023 __put_user(0, &sc->sc_regs[31]);
6024
6025 for (i = 0; i < 31; ++i) {
6026 __put_user(env->fir[i], &sc->sc_fpregs[i]);
6027 }
6028 __put_user(0, &sc->sc_fpregs[31]);
6029 __put_user(cpu_alpha_load_fpcr(env), &sc->sc_fpcr);
6030
6031 __put_user(0, &sc->sc_traparg_a0); /* FIXME */
6032 __put_user(0, &sc->sc_traparg_a1); /* FIXME */
6033 __put_user(0, &sc->sc_traparg_a2); /* FIXME */
6034 }
6035
6036 static void restore_sigcontext(CPUAlphaState *env,
6037 struct target_sigcontext *sc)
6038 {
6039 uint64_t fpcr;
6040 int i;
6041
6042 __get_user(env->pc, &sc->sc_pc);
6043
6044 for (i = 0; i < 31; ++i) {
6045 __get_user(env->ir[i], &sc->sc_regs[i]);
6046 }
6047 for (i = 0; i < 31; ++i) {
6048 __get_user(env->fir[i], &sc->sc_fpregs[i]);
6049 }
6050
6051 __get_user(fpcr, &sc->sc_fpcr);
6052 cpu_alpha_store_fpcr(env, fpcr);
6053 }
6054
6055 static inline abi_ulong get_sigframe(struct target_sigaction *sa,
6056 CPUAlphaState *env,
6057 unsigned long framesize)
6058 {
6059 abi_ulong sp = env->ir[IR_SP];
6060
6061 /* This is the X/Open sanctioned signal stack switching. */
6062 if ((sa->sa_flags & TARGET_SA_ONSTACK) != 0 && !sas_ss_flags(sp)) {
6063 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
6064 }
6065 return (sp - framesize) & -32;
6066 }
6067
6068 static void setup_frame(int sig, struct target_sigaction *ka,
6069 target_sigset_t *set, CPUAlphaState *env)
6070 {
6071 abi_ulong frame_addr, r26;
6072 struct target_sigframe *frame;
6073 int err = 0;
6074
6075 frame_addr = get_sigframe(ka, env, sizeof(*frame));
6076 trace_user_setup_frame(env, frame_addr);
6077 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
6078 goto give_sigsegv;
6079 }
6080
6081 setup_sigcontext(&frame->sc, env, frame_addr, set);
6082
6083 if (ka->sa_restorer) {
6084 r26 = ka->sa_restorer;
6085 } else {
6086 __put_user(INSN_MOV_R30_R16, &frame->retcode[0]);
6087 __put_user(INSN_LDI_R0 + TARGET_NR_sigreturn,
6088 &frame->retcode[1]);
6089 __put_user(INSN_CALLSYS, &frame->retcode[2]);
6090 /* imb() */
6091 r26 = frame_addr;
6092 }
6093
6094 unlock_user_struct(frame, frame_addr, 1);
6095
6096 if (err) {
6097 give_sigsegv:
6098 force_sigsegv(sig);
6099 return;
6100 }
6101
6102 env->ir[IR_RA] = r26;
6103 env->ir[IR_PV] = env->pc = ka->_sa_handler;
6104 env->ir[IR_A0] = sig;
6105 env->ir[IR_A1] = 0;
6106 env->ir[IR_A2] = frame_addr + offsetof(struct target_sigframe, sc);
6107 env->ir[IR_SP] = frame_addr;
6108 }
6109
6110 static void setup_rt_frame(int sig, struct target_sigaction *ka,
6111 target_siginfo_t *info,
6112 target_sigset_t *set, CPUAlphaState *env)
6113 {
6114 abi_ulong frame_addr, r26;
6115 struct target_rt_sigframe *frame;
6116 int i, err = 0;
6117
6118 frame_addr = get_sigframe(ka, env, sizeof(*frame));
6119 trace_user_setup_rt_frame(env, frame_addr);
6120 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
6121 goto give_sigsegv;
6122 }
6123
6124 tswap_siginfo(&frame->info, info);
6125
6126 __put_user(0, &frame->uc.tuc_flags);
6127 __put_user(0, &frame->uc.tuc_link);
6128 __put_user(set->sig[0], &frame->uc.tuc_osf_sigmask);
6129 __put_user(target_sigaltstack_used.ss_sp,
6130 &frame->uc.tuc_stack.ss_sp);
6131 __put_user(sas_ss_flags(env->ir[IR_SP]),
6132 &frame->uc.tuc_stack.ss_flags);
6133 __put_user(target_sigaltstack_used.ss_size,
6134 &frame->uc.tuc_stack.ss_size);
6135 setup_sigcontext(&frame->uc.tuc_mcontext, env, frame_addr, set);
6136 for (i = 0; i < TARGET_NSIG_WORDS; ++i) {
6137 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
6138 }
6139
6140 if (ka->sa_restorer) {
6141 r26 = ka->sa_restorer;
6142 } else {
6143 __put_user(INSN_MOV_R30_R16, &frame->retcode[0]);
6144 __put_user(INSN_LDI_R0 + TARGET_NR_rt_sigreturn,
6145 &frame->retcode[1]);
6146 __put_user(INSN_CALLSYS, &frame->retcode[2]);
6147 /* imb(); */
6148 r26 = frame_addr;
6149 }
6150
6151 if (err) {
6152 give_sigsegv:
6153 force_sigsegv(sig);
6154 return;
6155 }
6156
6157 env->ir[IR_RA] = r26;
6158 env->ir[IR_PV] = env->pc = ka->_sa_handler;
6159 env->ir[IR_A0] = sig;
6160 env->ir[IR_A1] = frame_addr + offsetof(struct target_rt_sigframe, info);
6161 env->ir[IR_A2] = frame_addr + offsetof(struct target_rt_sigframe, uc);
6162 env->ir[IR_SP] = frame_addr;
6163 }
6164
6165 long do_sigreturn(CPUAlphaState *env)
6166 {
6167 struct target_sigcontext *sc;
6168 abi_ulong sc_addr = env->ir[IR_A0];
6169 target_sigset_t target_set;
6170 sigset_t set;
6171
6172 if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1)) {
6173 goto badframe;
6174 }
6175
6176 target_sigemptyset(&target_set);
6177 __get_user(target_set.sig[0], &sc->sc_mask);
6178
6179 target_to_host_sigset_internal(&set, &target_set);
6180 set_sigmask(&set);
6181
6182 restore_sigcontext(env, sc);
6183 unlock_user_struct(sc, sc_addr, 0);
6184 return -TARGET_QEMU_ESIGRETURN;
6185
6186 badframe:
6187 force_sig(TARGET_SIGSEGV);
6188 return -TARGET_QEMU_ESIGRETURN;
6189 }
6190
6191 long do_rt_sigreturn(CPUAlphaState *env)
6192 {
6193 abi_ulong frame_addr = env->ir[IR_A0];
6194 struct target_rt_sigframe *frame;
6195 sigset_t set;
6196
6197 trace_user_do_rt_sigreturn(env, frame_addr);
6198 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
6199 goto badframe;
6200 }
6201 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
6202 set_sigmask(&set);
6203
6204 restore_sigcontext(env, &frame->uc.tuc_mcontext);
6205 if (do_sigaltstack(frame_addr + offsetof(struct target_rt_sigframe,
6206 uc.tuc_stack),
6207 0, env->ir[IR_SP]) == -EFAULT) {
6208 goto badframe;
6209 }
6210
6211 unlock_user_struct(frame, frame_addr, 0);
6212 return -TARGET_QEMU_ESIGRETURN;
6213
6214
6215 badframe:
6216 unlock_user_struct(frame, frame_addr, 0);
6217 force_sig(TARGET_SIGSEGV);
6218 return -TARGET_QEMU_ESIGRETURN;
6219 }
6220
6221 #elif defined(TARGET_TILEGX)
6222
6223 struct target_sigcontext {
6224 union {
6225 /* General-purpose registers. */
6226 abi_ulong gregs[56];
6227 struct {
6228 abi_ulong __gregs[53];
6229 abi_ulong tp; /* Aliases gregs[TREG_TP]. */
6230 abi_ulong sp; /* Aliases gregs[TREG_SP]. */
6231 abi_ulong lr; /* Aliases gregs[TREG_LR]. */
6232 };
6233 };
6234 abi_ulong pc; /* Program counter. */
6235 abi_ulong ics; /* In Interrupt Critical Section? */
6236 abi_ulong faultnum; /* Fault number. */
6237 abi_ulong pad[5];
6238 };
6239
6240 struct target_ucontext {
6241 abi_ulong tuc_flags;
6242 abi_ulong tuc_link;
6243 target_stack_t tuc_stack;
6244 struct target_sigcontext tuc_mcontext;
6245 target_sigset_t tuc_sigmask; /* mask last for extensibility */
6246 };
6247
6248 struct target_rt_sigframe {
6249 unsigned char save_area[16]; /* caller save area */
6250 struct target_siginfo info;
6251 struct target_ucontext uc;
6252 abi_ulong retcode[2];
6253 };
6254
6255 #define INSN_MOVELI_R10_139 0x00045fe551483000ULL /* { moveli r10, 139 } */
6256 #define INSN_SWINT1 0x286b180051485000ULL /* { swint1 } */
6257
6258
6259 static void setup_sigcontext(struct target_sigcontext *sc,
6260 CPUArchState *env, int signo)
6261 {
6262 int i;
6263
6264 for (i = 0; i < TILEGX_R_COUNT; ++i) {
6265 __put_user(env->regs[i], &sc->gregs[i]);
6266 }
6267
6268 __put_user(env->pc, &sc->pc);
6269 __put_user(0, &sc->ics);
6270 __put_user(signo, &sc->faultnum);
6271 }
6272
6273 static void restore_sigcontext(CPUTLGState *env, struct target_sigcontext *sc)
6274 {
6275 int i;
6276
6277 for (i = 0; i < TILEGX_R_COUNT; ++i) {
6278 __get_user(env->regs[i], &sc->gregs[i]);
6279 }
6280
6281 __get_user(env->pc, &sc->pc);
6282 }
6283
6284 static abi_ulong get_sigframe(struct target_sigaction *ka, CPUArchState *env,
6285 size_t frame_size)
6286 {
6287 unsigned long sp = env->regs[TILEGX_R_SP];
6288
6289 if (on_sig_stack(sp) && !likely(on_sig_stack(sp - frame_size))) {
6290 return -1UL;
6291 }
6292
6293 if ((ka->sa_flags & SA_ONSTACK) && !sas_ss_flags(sp)) {
6294 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
6295 }
6296
6297 sp -= frame_size;
6298 sp &= -16UL;
6299 return sp;
6300 }
6301
6302 static void setup_rt_frame(int sig, struct target_sigaction *ka,
6303 target_siginfo_t *info,
6304 target_sigset_t *set, CPUArchState *env)
6305 {
6306 abi_ulong frame_addr;
6307 struct target_rt_sigframe *frame;
6308 unsigned long restorer;
6309
6310 frame_addr = get_sigframe(ka, env, sizeof(*frame));
6311 trace_user_setup_rt_frame(env, frame_addr);
6312 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
6313 goto give_sigsegv;
6314 }
6315
6316 /* Always write at least the signal number for the stack backtracer. */
6317 if (ka->sa_flags & TARGET_SA_SIGINFO) {
6318 /* At sigreturn time, restore the callee-save registers too. */
6319 tswap_siginfo(&frame->info, info);
6320 /* regs->flags |= PT_FLAGS_RESTORE_REGS; FIXME: we can skip it? */
6321 } else {
6322 __put_user(info->si_signo, &frame->info.si_signo);
6323 }
6324
6325 /* Create the ucontext. */
6326 __put_user(0, &frame->uc.tuc_flags);
6327 __put_user(0, &frame->uc.tuc_link);
6328 __put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp);
6329 __put_user(sas_ss_flags(env->regs[TILEGX_R_SP]),
6330 &frame->uc.tuc_stack.ss_flags);
6331 __put_user(target_sigaltstack_used.ss_size, &frame->uc.tuc_stack.ss_size);
6332 setup_sigcontext(&frame->uc.tuc_mcontext, env, info->si_signo);
6333
6334 if (ka->sa_flags & TARGET_SA_RESTORER) {
6335 restorer = (unsigned long) ka->sa_restorer;
6336 } else {
6337 __put_user(INSN_MOVELI_R10_139, &frame->retcode[0]);
6338 __put_user(INSN_SWINT1, &frame->retcode[1]);
6339 restorer = frame_addr + offsetof(struct target_rt_sigframe, retcode);
6340 }
6341 env->pc = (unsigned long) ka->_sa_handler;
6342 env->regs[TILEGX_R_SP] = (unsigned long) frame;
6343 env->regs[TILEGX_R_LR] = restorer;
6344 env->regs[0] = (unsigned long) sig;
6345 env->regs[1] = (unsigned long) &frame->info;
6346 env->regs[2] = (unsigned long) &frame->uc;
6347 /* regs->flags |= PT_FLAGS_CALLER_SAVES; FIXME: we can skip it? */
6348
6349 unlock_user_struct(frame, frame_addr, 1);
6350 return;
6351
6352 give_sigsegv:
6353 force_sigsegv(sig);
6354 }
6355
6356 long do_rt_sigreturn(CPUTLGState *env)
6357 {
6358 abi_ulong frame_addr = env->regs[TILEGX_R_SP];
6359 struct target_rt_sigframe *frame;
6360 sigset_t set;
6361
6362 trace_user_do_rt_sigreturn(env, frame_addr);
6363 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
6364 goto badframe;
6365 }
6366 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
6367 set_sigmask(&set);
6368
6369 restore_sigcontext(env, &frame->uc.tuc_mcontext);
6370 if (do_sigaltstack(frame_addr + offsetof(struct target_rt_sigframe,
6371 uc.tuc_stack),
6372 0, env->regs[TILEGX_R_SP]) == -EFAULT) {
6373 goto badframe;
6374 }
6375
6376 unlock_user_struct(frame, frame_addr, 0);
6377 return -TARGET_QEMU_ESIGRETURN;
6378
6379
6380 badframe:
6381 unlock_user_struct(frame, frame_addr, 0);
6382 force_sig(TARGET_SIGSEGV);
6383 return -TARGET_QEMU_ESIGRETURN;
6384 }
6385
6386 #elif defined(TARGET_HPPA)
6387
6388 struct target_sigcontext {
6389 abi_ulong sc_flags;
6390 abi_ulong sc_gr[32];
6391 uint64_t sc_fr[32];
6392 abi_ulong sc_iasq[2];
6393 abi_ulong sc_iaoq[2];
6394 abi_ulong sc_sar;
6395 };
6396
6397 struct target_ucontext {
6398 abi_uint tuc_flags;
6399 abi_ulong tuc_link;
6400 target_stack_t tuc_stack;
6401 abi_uint pad[1];
6402 struct target_sigcontext tuc_mcontext;
6403 target_sigset_t tuc_sigmask;
6404 };
6405
6406 struct target_rt_sigframe {
6407 abi_uint tramp[9];
6408 target_siginfo_t info;
6409 struct target_ucontext uc;
6410 /* hidden location of upper halves of pa2.0 64-bit gregs */
6411 };
6412
6413 static void setup_sigcontext(struct target_sigcontext *sc, CPUArchState *env)
6414 {
6415 int flags = 0;
6416 int i;
6417
6418 /* ??? if on_sig_stack, flags |= 1 (PARISC_SC_FLAG_ONSTACK). */
6419
6420 if (env->iaoq_f < TARGET_PAGE_SIZE) {
6421 /* In the gateway page, executing a syscall. */
6422 flags |= 2; /* PARISC_SC_FLAG_IN_SYSCALL */
6423 __put_user(env->gr[31], &sc->sc_iaoq[0]);
6424 __put_user(env->gr[31] + 4, &sc->sc_iaoq[1]);
6425 } else {
6426 __put_user(env->iaoq_f, &sc->sc_iaoq[0]);
6427 __put_user(env->iaoq_b, &sc->sc_iaoq[1]);
6428 }
6429 __put_user(0, &sc->sc_iasq[0]);
6430 __put_user(0, &sc->sc_iasq[1]);
6431 __put_user(flags, &sc->sc_flags);
6432
6433 __put_user(cpu_hppa_get_psw(env), &sc->sc_gr[0]);
6434 for (i = 1; i < 32; ++i) {
6435 __put_user(env->gr[i], &sc->sc_gr[i]);
6436 }
6437
6438 __put_user((uint64_t)env->fr0_shadow << 32, &sc->sc_fr[0]);
6439 for (i = 1; i < 32; ++i) {
6440 __put_user(env->fr[i], &sc->sc_fr[i]);
6441 }
6442
6443 __put_user(env->sar, &sc->sc_sar);
6444 }
6445
6446 static void restore_sigcontext(CPUArchState *env, struct target_sigcontext *sc)
6447 {
6448 target_ulong psw;
6449 int i;
6450
6451 __get_user(psw, &sc->sc_gr[0]);
6452 cpu_hppa_put_psw(env, psw);
6453
6454 for (i = 1; i < 32; ++i) {
6455 __get_user(env->gr[i], &sc->sc_gr[i]);
6456 }
6457 for (i = 0; i < 32; ++i) {
6458 __get_user(env->fr[i], &sc->sc_fr[i]);
6459 }
6460 cpu_hppa_loaded_fr0(env);
6461
6462 __get_user(env->iaoq_f, &sc->sc_iaoq[0]);
6463 __get_user(env->iaoq_b, &sc->sc_iaoq[1]);
6464 __get_user(env->sar, &sc->sc_sar);
6465 }
6466
6467 /* No, this doesn't look right, but it's copied straight from the kernel. */
6468 #define PARISC_RT_SIGFRAME_SIZE32 \
6469 ((sizeof(struct target_rt_sigframe) + 48 + 64) & -64)
6470
6471 static void setup_rt_frame(int sig, struct target_sigaction *ka,
6472 target_siginfo_t *info,
6473 target_sigset_t *set, CPUArchState *env)
6474 {
6475 abi_ulong frame_addr, sp, haddr;
6476 struct target_rt_sigframe *frame;
6477 int i;
6478
6479 sp = env->gr[30];
6480 if (ka->sa_flags & TARGET_SA_ONSTACK) {
6481 if (sas_ss_flags(sp) == 0) {
6482 sp = (target_sigaltstack_used.ss_sp + 0x7f) & ~0x3f;
6483 }
6484 }
6485 frame_addr = QEMU_ALIGN_UP(sp, 64);
6486 sp = frame_addr + PARISC_RT_SIGFRAME_SIZE32;
6487
6488 trace_user_setup_rt_frame(env, frame_addr);
6489
6490 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
6491 goto give_sigsegv;
6492 }
6493
6494 tswap_siginfo(&frame->info, info);
6495 frame->uc.tuc_flags = 0;
6496 frame->uc.tuc_link = 0;
6497
6498 __put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp);
6499 __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
6500 &frame->uc.tuc_stack.ss_flags);
6501 __put_user(target_sigaltstack_used.ss_size,
6502 &frame->uc.tuc_stack.ss_size);
6503
6504 for (i = 0; i < TARGET_NSIG_WORDS; i++) {
6505 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
6506 }
6507
6508 setup_sigcontext(&frame->uc.tuc_mcontext, env);
6509
6510 __put_user(0x34190000, frame->tramp + 0); /* ldi 0,%r25 */
6511 __put_user(0x3414015a, frame->tramp + 1); /* ldi __NR_rt_sigreturn,%r20 */
6512 __put_user(0xe4008200, frame->tramp + 2); /* be,l 0x100(%sr2,%r0) */
6513 __put_user(0x08000240, frame->tramp + 3); /* nop */
6514
6515 unlock_user_struct(frame, frame_addr, 1);
6516
6517 env->gr[2] = h2g(frame->tramp);
6518 env->gr[30] = sp;
6519 env->gr[26] = sig;
6520 env->gr[25] = h2g(&frame->info);
6521 env->gr[24] = h2g(&frame->uc);
6522
6523 haddr = ka->_sa_handler;
6524 if (haddr & 2) {
6525 /* Function descriptor. */
6526 target_ulong *fdesc, dest;
6527
6528 haddr &= -4;
6529 if (!lock_user_struct(VERIFY_READ, fdesc, haddr, 1)) {
6530 goto give_sigsegv;
6531 }
6532 __get_user(dest, fdesc);
6533 __get_user(env->gr[19], fdesc + 1);
6534 unlock_user_struct(fdesc, haddr, 1);
6535 haddr = dest;
6536 }
6537 env->iaoq_f = haddr;
6538 env->iaoq_b = haddr + 4;
6539 return;
6540
6541 give_sigsegv:
6542 force_sigsegv(sig);
6543 }
6544
6545 long do_rt_sigreturn(CPUArchState *env)
6546 {
6547 abi_ulong frame_addr = env->gr[30] - PARISC_RT_SIGFRAME_SIZE32;
6548 struct target_rt_sigframe *frame;
6549 sigset_t set;
6550
6551 trace_user_do_rt_sigreturn(env, frame_addr);
6552 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
6553 goto badframe;
6554 }
6555 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
6556 set_sigmask(&set);
6557
6558 restore_sigcontext(env, &frame->uc.tuc_mcontext);
6559 unlock_user_struct(frame, frame_addr, 0);
6560
6561 if (do_sigaltstack(frame_addr + offsetof(struct target_rt_sigframe,
6562 uc.tuc_stack),
6563 0, env->gr[30]) == -EFAULT) {
6564 goto badframe;
6565 }
6566
6567 unlock_user_struct(frame, frame_addr, 0);
6568 return -TARGET_QEMU_ESIGRETURN;
6569
6570 badframe:
6571 force_sig(TARGET_SIGSEGV);
6572 return -TARGET_QEMU_ESIGRETURN;
6573 }
6574
6575 #else
6576
6577 static void setup_frame(int sig, struct target_sigaction *ka,
6578 target_sigset_t *set, CPUArchState *env)
6579 {
6580 fprintf(stderr, "setup_frame: not implemented\n");
6581 }
6582
6583 static void setup_rt_frame(int sig, struct target_sigaction *ka,
6584 target_siginfo_t *info,
6585 target_sigset_t *set, CPUArchState *env)
6586 {
6587 fprintf(stderr, "setup_rt_frame: not implemented\n");
6588 }
6589
6590 long do_sigreturn(CPUArchState *env)
6591 {
6592 fprintf(stderr, "do_sigreturn: not implemented\n");
6593 return -TARGET_ENOSYS;
6594 }
6595
6596 long do_rt_sigreturn(CPUArchState *env)
6597 {
6598 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
6599 return -TARGET_ENOSYS;
6600 }
6601
6602 #endif
6603
6604 static void handle_pending_signal(CPUArchState *cpu_env, int sig,
6605 struct emulated_sigtable *k)
6606 {
6607 CPUState *cpu = ENV_GET_CPU(cpu_env);
6608 abi_ulong handler;
6609 sigset_t set;
6610 target_sigset_t target_old_set;
6611 struct target_sigaction *sa;
6612 TaskState *ts = cpu->opaque;
6613
6614 trace_user_handle_signal(cpu_env, sig);
6615 /* dequeue signal */
6616 k->pending = 0;
6617
6618 sig = gdb_handlesig(cpu, sig);
6619 if (!sig) {
6620 sa = NULL;
6621 handler = TARGET_SIG_IGN;
6622 } else {
6623 sa = &sigact_table[sig - 1];
6624 handler = sa->_sa_handler;
6625 }
6626
6627 if (do_strace) {
6628 print_taken_signal(sig, &k->info);
6629 }
6630
6631 if (handler == TARGET_SIG_DFL) {
6632 /* default handler : ignore some signal. The other are job control or fatal */
6633 if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) {
6634 kill(getpid(),SIGSTOP);
6635 } else if (sig != TARGET_SIGCHLD &&
6636 sig != TARGET_SIGURG &&
6637 sig != TARGET_SIGWINCH &&
6638 sig != TARGET_SIGCONT) {
6639 dump_core_and_abort(sig);
6640 }
6641 } else if (handler == TARGET_SIG_IGN) {
6642 /* ignore sig */
6643 } else if (handler == TARGET_SIG_ERR) {
6644 dump_core_and_abort(sig);
6645 } else {
6646 /* compute the blocked signals during the handler execution */
6647 sigset_t *blocked_set;
6648
6649 target_to_host_sigset(&set, &sa->sa_mask);
6650 /* SA_NODEFER indicates that the current signal should not be
6651 blocked during the handler */
6652 if (!(sa->sa_flags & TARGET_SA_NODEFER))
6653 sigaddset(&set, target_to_host_signal(sig));
6654
6655 /* save the previous blocked signal state to restore it at the
6656 end of the signal execution (see do_sigreturn) */
6657 host_to_target_sigset_internal(&target_old_set, &ts->signal_mask);
6658
6659 /* block signals in the handler */
6660 blocked_set = ts->in_sigsuspend ?
6661 &ts->sigsuspend_mask : &ts->signal_mask;
6662 sigorset(&ts->signal_mask, blocked_set, &set);
6663 ts->in_sigsuspend = 0;
6664
6665 /* if the CPU is in VM86 mode, we restore the 32 bit values */
6666 #if defined(TARGET_I386) && !defined(TARGET_X86_64)
6667 {
6668 CPUX86State *env = cpu_env;
6669 if (env->eflags & VM_MASK)
6670 save_v86_state(env);
6671 }
6672 #endif
6673 /* prepare the stack frame of the virtual CPU */
6674 #if defined(TARGET_ABI_MIPSN32) || defined(TARGET_ABI_MIPSN64) \
6675 || defined(TARGET_OPENRISC) || defined(TARGET_TILEGX) \
6676 || defined(TARGET_PPC64) || defined(TARGET_HPPA) \
6677 || defined(TARGET_NIOS2) || defined(TARGET_X86_64)
6678 /* These targets do not have traditional signals. */
6679 setup_rt_frame(sig, sa, &k->info, &target_old_set, cpu_env);
6680 #else
6681 if (sa->sa_flags & TARGET_SA_SIGINFO)
6682 setup_rt_frame(sig, sa, &k->info, &target_old_set, cpu_env);
6683 else
6684 setup_frame(sig, sa, &target_old_set, cpu_env);
6685 #endif
6686 if (sa->sa_flags & TARGET_SA_RESETHAND) {
6687 sa->_sa_handler = TARGET_SIG_DFL;
6688 }
6689 }
6690 }
6691
6692 void process_pending_signals(CPUArchState *cpu_env)
6693 {
6694 CPUState *cpu = ENV_GET_CPU(cpu_env);
6695 int sig;
6696 TaskState *ts = cpu->opaque;
6697 sigset_t set;
6698 sigset_t *blocked_set;
6699
6700 while (atomic_read(&ts->signal_pending)) {
6701 /* FIXME: This is not threadsafe. */
6702 sigfillset(&set);
6703 sigprocmask(SIG_SETMASK, &set, 0);
6704
6705 restart_scan:
6706 sig = ts->sync_signal.pending;
6707 if (sig) {
6708 /* Synchronous signals are forced,
6709 * see force_sig_info() and callers in Linux
6710 * Note that not all of our queue_signal() calls in QEMU correspond
6711 * to force_sig_info() calls in Linux (some are send_sig_info()).
6712 * However it seems like a kernel bug to me to allow the process
6713 * to block a synchronous signal since it could then just end up
6714 * looping round and round indefinitely.
6715 */
6716 if (sigismember(&ts->signal_mask, target_to_host_signal_table[sig])
6717 || sigact_table[sig - 1]._sa_handler == TARGET_SIG_IGN) {
6718 sigdelset(&ts->signal_mask, target_to_host_signal_table[sig]);
6719 sigact_table[sig - 1]._sa_handler = TARGET_SIG_DFL;
6720 }
6721
6722 handle_pending_signal(cpu_env, sig, &ts->sync_signal);
6723 }
6724
6725 for (sig = 1; sig <= TARGET_NSIG; sig++) {
6726 blocked_set = ts->in_sigsuspend ?
6727 &ts->sigsuspend_mask : &ts->signal_mask;
6728
6729 if (ts->sigtab[sig - 1].pending &&
6730 (!sigismember(blocked_set,
6731 target_to_host_signal_table[sig]))) {
6732 handle_pending_signal(cpu_env, sig, &ts->sigtab[sig - 1]);
6733 /* Restart scan from the beginning, as handle_pending_signal
6734 * might have resulted in a new synchronous signal (eg SIGSEGV).
6735 */
6736 goto restart_scan;
6737 }
6738 }
6739
6740 /* if no signal is pending, unblock signals and recheck (the act
6741 * of unblocking might cause us to take another host signal which
6742 * will set signal_pending again).
6743 */
6744 atomic_set(&ts->signal_pending, 0);
6745 ts->in_sigsuspend = 0;
6746 set = ts->signal_mask;
6747 sigdelset(&set, SIGSEGV);
6748 sigdelset(&set, SIGBUS);
6749 sigprocmask(SIG_SETMASK, &set, 0);
6750 }
6751 ts->in_sigsuspend = 0;
6752 }
AR7 emulation for QEMU