]> git.proxmox.com Git - qemu.git/blob - linux-user/signal.c
projects / qemu.git / blob
? search:


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