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