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