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