?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix SCSI off-by-one device size.
[qemu/mini2440.git] / linux-user / signal.c
blob60f9eb767c49c71b6ae76e95cd2359acf6d766e5
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., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20 #include <stdlib.h>
21 #include <stdio.h>
22 #include <string.h>
23 #include <stdarg.h>
24 #include <unistd.h>
25 #include <signal.h>
26 #include <errno.h>
27 #include <sys/ucontext.h>
28
29 #include "qemu.h"
30
31 //#define DEBUG_SIGNAL
32
33 #define MAX_SIGQUEUE_SIZE 1024
34
35 struct sigqueue {
36 struct sigqueue *next;
37 target_siginfo_t info;
38 };
39
40 struct emulated_sigaction {
41 struct target_sigaction sa;
42 int pending; /* true if signal is pending */
43 struct sigqueue *first;
44 struct sigqueue info; /* in order to always have memory for the
45 first signal, we put it here */
46 };
47
48 static struct emulated_sigaction sigact_table[TARGET_NSIG];
49 static struct sigqueue sigqueue_table[MAX_SIGQUEUE_SIZE]; /* siginfo queue */
50 static struct sigqueue *first_free; /* first free siginfo queue entry */
51 static int signal_pending; /* non zero if a signal may be pending */
52
53 static void host_signal_handler(int host_signum, siginfo_t *info,
54 void *puc);
55
56 static uint8_t host_to_target_signal_table[65] = {
57 [SIGHUP] = TARGET_SIGHUP,
58 [SIGINT] = TARGET_SIGINT,
59 [SIGQUIT] = TARGET_SIGQUIT,
60 [SIGILL] = TARGET_SIGILL,
61 [SIGTRAP] = TARGET_SIGTRAP,
62 [SIGABRT] = TARGET_SIGABRT,
63 /* [SIGIOT] = TARGET_SIGIOT,*/
64 [SIGBUS] = TARGET_SIGBUS,
65 [SIGFPE] = TARGET_SIGFPE,
66 [SIGKILL] = TARGET_SIGKILL,
67 [SIGUSR1] = TARGET_SIGUSR1,
68 [SIGSEGV] = TARGET_SIGSEGV,
69 [SIGUSR2] = TARGET_SIGUSR2,
70 [SIGPIPE] = TARGET_SIGPIPE,
71 [SIGALRM] = TARGET_SIGALRM,
72 [SIGTERM] = TARGET_SIGTERM,
73 #ifdef SIGSTKFLT
74 [SIGSTKFLT] = TARGET_SIGSTKFLT,
75 #endif
76 [SIGCHLD] = TARGET_SIGCHLD,
77 [SIGCONT] = TARGET_SIGCONT,
78 [SIGSTOP] = TARGET_SIGSTOP,
79 [SIGTSTP] = TARGET_SIGTSTP,
80 [SIGTTIN] = TARGET_SIGTTIN,
81 [SIGTTOU] = TARGET_SIGTTOU,
82 [SIGURG] = TARGET_SIGURG,
83 [SIGXCPU] = TARGET_SIGXCPU,
84 [SIGXFSZ] = TARGET_SIGXFSZ,
85 [SIGVTALRM] = TARGET_SIGVTALRM,
86 [SIGPROF] = TARGET_SIGPROF,
87 [SIGWINCH] = TARGET_SIGWINCH,
88 [SIGIO] = TARGET_SIGIO,
89 [SIGPWR] = TARGET_SIGPWR,
90 [SIGSYS] = TARGET_SIGSYS,
91 /* next signals stay the same */
92 };
93 static uint8_t target_to_host_signal_table[65];
94
95 static inline int host_to_target_signal(int sig)
96 {
97 return host_to_target_signal_table[sig];
98 }
99
100 static inline int target_to_host_signal(int sig)
101 {
102 return target_to_host_signal_table[sig];
103 }
104
105 static void host_to_target_sigset_internal(target_sigset_t *d,
106 const sigset_t *s)
107 {
108 int i;
109 unsigned long sigmask;
110 uint32_t target_sigmask;
111
112 sigmask = ((unsigned long *)s)[0];
113 target_sigmask = 0;
114 for(i = 0; i < 32; i++) {
115 if (sigmask & (1 << i))
116 target_sigmask |= 1 << (host_to_target_signal(i + 1) - 1);
117 }
118 #if TARGET_LONG_BITS == 32 && HOST_LONG_BITS == 32
119 d->sig[0] = target_sigmask;
120 for(i = 1;i < TARGET_NSIG_WORDS; i++) {
121 d->sig[i] = ((unsigned long *)s)[i];
122 }
123 #elif TARGET_LONG_BITS == 32 && HOST_LONG_BITS == 64 && TARGET_NSIG_WORDS == 2
124 d->sig[0] = target_sigmask;
125 d->sig[1] = sigmask >> 32;
126 #else
127 #warning host_to_target_sigset
128 #endif
129 }
130
131 void host_to_target_sigset(target_sigset_t *d, const sigset_t *s)
132 {
133 target_sigset_t d1;
134 int i;
135
136 host_to_target_sigset_internal(&d1, s);
137 for(i = 0;i < TARGET_NSIG_WORDS; i++)
138 d->sig[i] = tswapl(d1.sig[i]);
139 }
140
141 void target_to_host_sigset_internal(sigset_t *d, const target_sigset_t *s)
142 {
143 int i;
144 unsigned long sigmask;
145 target_ulong target_sigmask;
146
147 target_sigmask = s->sig[0];
148 sigmask = 0;
149 for(i = 0; i < 32; i++) {
150 if (target_sigmask & (1 << i))
151 sigmask |= 1 << (target_to_host_signal(i + 1) - 1);
152 }
153 #if TARGET_LONG_BITS == 32 && HOST_LONG_BITS == 32
154 ((unsigned long *)d)[0] = sigmask;
155 for(i = 1;i < TARGET_NSIG_WORDS; i++) {
156 ((unsigned long *)d)[i] = s->sig[i];
157 }
158 #elif TARGET_LONG_BITS == 32 && HOST_LONG_BITS == 64 && TARGET_NSIG_WORDS == 2
159 ((unsigned long *)d)[0] = sigmask | ((unsigned long)(s->sig[1]) << 32);
160 #else
161 #warning target_to_host_sigset
162 #endif /* TARGET_LONG_BITS */
163 }
164
165 void target_to_host_sigset(sigset_t *d, const target_sigset_t *s)
166 {
167 target_sigset_t s1;
168 int i;
169
170 for(i = 0;i < TARGET_NSIG_WORDS; i++)
171 s1.sig[i] = tswapl(s->sig[i]);
172 target_to_host_sigset_internal(d, &s1);
173 }
174
175 void host_to_target_old_sigset(target_ulong *old_sigset,
176 const sigset_t *sigset)
177 {
178 target_sigset_t d;
179 host_to_target_sigset(&d, sigset);
180 *old_sigset = d.sig[0];
181 }
182
183 void target_to_host_old_sigset(sigset_t *sigset,
184 const target_ulong *old_sigset)
185 {
186 target_sigset_t d;
187 int i;
188
189 d.sig[0] = *old_sigset;
190 for(i = 1;i < TARGET_NSIG_WORDS; i++)
191 d.sig[i] = 0;
192 target_to_host_sigset(sigset, &d);
193 }
194
195 /* siginfo conversion */
196
197 static inline void host_to_target_siginfo_noswap(target_siginfo_t *tinfo,
198 const siginfo_t *info)
199 {
200 int sig;
201 sig = host_to_target_signal(info->si_signo);
202 tinfo->si_signo = sig;
203 tinfo->si_errno = 0;
204 tinfo->si_code = 0;
205 if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV ||
206 sig == SIGBUS || sig == SIGTRAP) {
207 /* should never come here, but who knows. The information for
208 the target is irrelevant */
209 tinfo->_sifields._sigfault._addr = 0;
210 } else if (sig >= TARGET_SIGRTMIN) {
211 tinfo->_sifields._rt._pid = info->si_pid;
212 tinfo->_sifields._rt._uid = info->si_uid;
213 /* XXX: potential problem if 64 bit */
214 tinfo->_sifields._rt._sigval.sival_ptr =
215 (target_ulong)info->si_value.sival_ptr;
216 }
217 }
218
219 static void tswap_siginfo(target_siginfo_t *tinfo,
220 const target_siginfo_t *info)
221 {
222 int sig;
223 sig = info->si_signo;
224 tinfo->si_signo = tswap32(sig);
225 tinfo->si_errno = tswap32(info->si_errno);
226 tinfo->si_code = tswap32(info->si_code);
227 if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV ||
228 sig == SIGBUS || sig == SIGTRAP) {
229 tinfo->_sifields._sigfault._addr =
230 tswapl(info->_sifields._sigfault._addr);
231 } else if (sig >= TARGET_SIGRTMIN) {
232 tinfo->_sifields._rt._pid = tswap32(info->_sifields._rt._pid);
233 tinfo->_sifields._rt._uid = tswap32(info->_sifields._rt._uid);
234 tinfo->_sifields._rt._sigval.sival_ptr =
235 tswapl(info->_sifields._rt._sigval.sival_ptr);
236 }
237 }
238
239
240 void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info)
241 {
242 host_to_target_siginfo_noswap(tinfo, info);
243 tswap_siginfo(tinfo, tinfo);
244 }
245
246 /* XXX: we support only POSIX RT signals are used. */
247 /* XXX: find a solution for 64 bit (additionnal malloced data is needed) */
248 void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo)
249 {
250 info->si_signo = tswap32(tinfo->si_signo);
251 info->si_errno = tswap32(tinfo->si_errno);
252 info->si_code = tswap32(tinfo->si_code);
253 info->si_pid = tswap32(tinfo->_sifields._rt._pid);
254 info->si_uid = tswap32(tinfo->_sifields._rt._uid);
255 info->si_value.sival_ptr =
256 (void *)tswapl(tinfo->_sifields._rt._sigval.sival_ptr);
257 }
258
259 void signal_init(void)
260 {
261 struct sigaction act;
262 int i, j;
263
264 /* generate signal conversion tables */
265 for(i = 1; i <= 64; i++) {
266 if (host_to_target_signal_table[i] == 0)
267 host_to_target_signal_table[i] = i;
268 }
269 for(i = 1; i <= 64; i++) {
270 j = host_to_target_signal_table[i];
271 target_to_host_signal_table[j] = i;
272 }
273
274 /* set all host signal handlers. ALL signals are blocked during
275 the handlers to serialize them. */
276 sigfillset(&act.sa_mask);
277 act.sa_flags = SA_SIGINFO;
278 act.sa_sigaction = host_signal_handler;
279 for(i = 1; i < NSIG; i++) {
280 sigaction(i, &act, NULL);
281 }
282
283 memset(sigact_table, 0, sizeof(sigact_table));
284
285 first_free = &sigqueue_table[0];
286 for(i = 0; i < MAX_SIGQUEUE_SIZE - 1; i++)
287 sigqueue_table[i].next = &sigqueue_table[i + 1];
288 sigqueue_table[MAX_SIGQUEUE_SIZE - 1].next = NULL;
289 }
290
291 /* signal queue handling */
292
293 static inline struct sigqueue *alloc_sigqueue(void)
294 {
295 struct sigqueue *q = first_free;
296 if (!q)
297 return NULL;
298 first_free = q->next;
299 return q;
300 }
301
302 static inline void free_sigqueue(struct sigqueue *q)
303 {
304 q->next = first_free;
305 first_free = q;
306 }
307
308 /* abort execution with signal */
309 void __attribute((noreturn)) force_sig(int sig)
310 {
311 int host_sig;
312 host_sig = target_to_host_signal(sig);
313 fprintf(stderr, "qemu: uncaught target signal %d (%s) - exiting\n",
314 sig, strsignal(host_sig));
315 #if 1
316 _exit(-host_sig);
317 #else
318 {
319 struct sigaction act;
320 sigemptyset(&act.sa_mask);
321 act.sa_flags = SA_SIGINFO;
322 act.sa_sigaction = SIG_DFL;
323 sigaction(SIGABRT, &act, NULL);
324 abort();
325 }
326 #endif
327 }
328
329 /* queue a signal so that it will be send to the virtual CPU as soon
330 as possible */
331 int queue_signal(int sig, target_siginfo_t *info)
332 {
333 struct emulated_sigaction *k;
334 struct sigqueue *q, **pq;
335 target_ulong handler;
336
337 #if defined(DEBUG_SIGNAL)
338 fprintf(stderr, "queue_signal: sig=%d\n",
339 sig);
340 #endif
341 k = &sigact_table[sig - 1];
342 handler = k->sa._sa_handler;
343 if (handler == TARGET_SIG_DFL) {
344 /* default handler : ignore some signal. The other are fatal */
345 if (sig != TARGET_SIGCHLD &&
346 sig != TARGET_SIGURG &&
347 sig != TARGET_SIGWINCH) {
348 force_sig(sig);
349 } else {
350 return 0; /* indicate ignored */
351 }
352 } else if (handler == TARGET_SIG_IGN) {
353 /* ignore signal */
354 return 0;
355 } else if (handler == TARGET_SIG_ERR) {
356 force_sig(sig);
357 } else {
358 pq = &k->first;
359 if (sig < TARGET_SIGRTMIN) {
360 /* if non real time signal, we queue exactly one signal */
361 if (!k->pending)
362 q = &k->info;
363 else
364 return 0;
365 } else {
366 if (!k->pending) {
367 /* first signal */
368 q = &k->info;
369 } else {
370 q = alloc_sigqueue();
371 if (!q)
372 return -EAGAIN;
373 while (*pq != NULL)
374 pq = &(*pq)->next;
375 }
376 }
377 *pq = q;
378 q->info = *info;
379 q->next = NULL;
380 k->pending = 1;
381 /* signal that a new signal is pending */
382 signal_pending = 1;
383 return 1; /* indicates that the signal was queued */
384 }
385 }
386
387 static void host_signal_handler(int host_signum, siginfo_t *info,
388 void *puc)
389 {
390 int sig;
391 target_siginfo_t tinfo;
392
393 /* the CPU emulator uses some host signals to detect exceptions,
394 we we forward to it some signals */
395 if (host_signum == SIGSEGV || host_signum == SIGBUS
396 #if defined(TARGET_I386) && defined(USE_CODE_COPY)
397 || host_signum == SIGFPE
398 #endif
399 ) {
400 if (cpu_signal_handler(host_signum, info, puc))
401 return;
402 }
403
404 /* get target signal number */
405 sig = host_to_target_signal(host_signum);
406 if (sig < 1 || sig > TARGET_NSIG)
407 return;
408 #if defined(DEBUG_SIGNAL)
409 fprintf(stderr, "qemu: got signal %d\n", sig);
410 #endif
411 host_to_target_siginfo_noswap(&tinfo, info);
412 if (queue_signal(sig, &tinfo) == 1) {
413 /* interrupt the virtual CPU as soon as possible */
414 cpu_interrupt(global_env, CPU_INTERRUPT_EXIT);
415 }
416 }
417
418 int do_sigaction(int sig, const struct target_sigaction *act,
419 struct target_sigaction *oact)
420 {
421 struct emulated_sigaction *k;
422 struct sigaction act1;
423 int host_sig;
424
425 if (sig < 1 || sig > TARGET_NSIG)
426 return -EINVAL;
427 k = &sigact_table[sig - 1];
428 #if defined(DEBUG_SIGNAL)
429 fprintf(stderr, "sigaction sig=%d act=0x%08x, oact=0x%08x\n",
430 sig, (int)act, (int)oact);
431 #endif
432 if (oact) {
433 oact->_sa_handler = tswapl(k->sa._sa_handler);
434 oact->sa_flags = tswapl(k->sa.sa_flags);
435 #if !defined(TARGET_MIPS)
436 oact->sa_restorer = tswapl(k->sa.sa_restorer);
437 #endif
438 oact->sa_mask = k->sa.sa_mask;
439 }
440 if (act) {
441 k->sa._sa_handler = tswapl(act->_sa_handler);
442 k->sa.sa_flags = tswapl(act->sa_flags);
443 #if !defined(TARGET_MIPS)
444 k->sa.sa_restorer = tswapl(act->sa_restorer);
445 #endif
446 k->sa.sa_mask = act->sa_mask;
447
448 /* we update the host linux signal state */
449 host_sig = target_to_host_signal(sig);
450 if (host_sig != SIGSEGV && host_sig != SIGBUS) {
451 sigfillset(&act1.sa_mask);
452 act1.sa_flags = SA_SIGINFO;
453 if (k->sa.sa_flags & TARGET_SA_RESTART)
454 act1.sa_flags |= SA_RESTART;
455 /* NOTE: it is important to update the host kernel signal
456 ignore state to avoid getting unexpected interrupted
457 syscalls */
458 if (k->sa._sa_handler == TARGET_SIG_IGN) {
459 act1.sa_sigaction = (void *)SIG_IGN;
460 } else if (k->sa._sa_handler == TARGET_SIG_DFL) {
461 act1.sa_sigaction = (void *)SIG_DFL;
462 } else {
463 act1.sa_sigaction = host_signal_handler;
464 }
465 sigaction(host_sig, &act1, NULL);
466 }
467 }
468 return 0;
469 }
470
471 #ifndef offsetof
472 #define offsetof(type, field) ((size_t) &((type *)0)->field)
473 #endif
474
475 static inline int copy_siginfo_to_user(target_siginfo_t *tinfo,
476 const target_siginfo_t *info)
477 {
478 tswap_siginfo(tinfo, info);
479 return 0;
480 }
481
482 #ifdef TARGET_I386
483
484 /* from the Linux kernel */
485
486 struct target_fpreg {
487 uint16_t significand[4];
488 uint16_t exponent;
489 };
490
491 struct target_fpxreg {
492 uint16_t significand[4];
493 uint16_t exponent;
494 uint16_t padding[3];
495 };
496
497 struct target_xmmreg {
498 target_ulong element[4];
499 };
500
501 struct target_fpstate {
502 /* Regular FPU environment */
503 target_ulong cw;
504 target_ulong sw;
505 target_ulong tag;
506 target_ulong ipoff;
507 target_ulong cssel;
508 target_ulong dataoff;
509 target_ulong datasel;
510 struct target_fpreg _st[8];
511 uint16_t status;
512 uint16_t magic; /* 0xffff = regular FPU data only */
513
514 /* FXSR FPU environment */
515 target_ulong _fxsr_env[6]; /* FXSR FPU env is ignored */
516 target_ulong mxcsr;
517 target_ulong reserved;
518 struct target_fpxreg _fxsr_st[8]; /* FXSR FPU reg data is ignored */
519 struct target_xmmreg _xmm[8];
520 target_ulong padding[56];
521 };
522
523 #define X86_FXSR_MAGIC 0x0000
524
525 struct target_sigcontext {
526 uint16_t gs, __gsh;
527 uint16_t fs, __fsh;
528 uint16_t es, __esh;
529 uint16_t ds, __dsh;
530 target_ulong edi;
531 target_ulong esi;
532 target_ulong ebp;
533 target_ulong esp;
534 target_ulong ebx;
535 target_ulong edx;
536 target_ulong ecx;
537 target_ulong eax;
538 target_ulong trapno;
539 target_ulong err;
540 target_ulong eip;
541 uint16_t cs, __csh;
542 target_ulong eflags;
543 target_ulong esp_at_signal;
544 uint16_t ss, __ssh;
545 target_ulong fpstate; /* pointer */
546 target_ulong oldmask;
547 target_ulong cr2;
548 };
549
550 typedef struct target_sigaltstack {
551 target_ulong ss_sp;
552 int ss_flags;
553 target_ulong ss_size;
554 } target_stack_t;
555
556 struct target_ucontext {
557 target_ulong tuc_flags;
558 target_ulong tuc_link;
559 target_stack_t tuc_stack;
560 struct target_sigcontext tuc_mcontext;
561 target_sigset_t tuc_sigmask; /* mask last for extensibility */
562 };
563
564 struct sigframe
565 {
566 target_ulong pretcode;
567 int sig;
568 struct target_sigcontext sc;
569 struct target_fpstate fpstate;
570 target_ulong extramask[TARGET_NSIG_WORDS-1];
571 char retcode[8];
572 };
573
574 struct rt_sigframe
575 {
576 target_ulong pretcode;
577 int sig;
578 target_ulong pinfo;
579 target_ulong puc;
580 struct target_siginfo info;
581 struct target_ucontext uc;
582 struct target_fpstate fpstate;
583 char retcode[8];
584 };
585
586 /*
587 * Set up a signal frame.
588 */
589
590 /* XXX: save x87 state */
591 static int
592 setup_sigcontext(struct target_sigcontext *sc, struct target_fpstate *fpstate,
593 CPUX86State *env, unsigned long mask)
594 {
595 int err = 0;
596
597 err |= __put_user(env->segs[R_GS].selector, (unsigned int *)&sc->gs);
598 err |= __put_user(env->segs[R_FS].selector, (unsigned int *)&sc->fs);
599 err |= __put_user(env->segs[R_ES].selector, (unsigned int *)&sc->es);
600 err |= __put_user(env->segs[R_DS].selector, (unsigned int *)&sc->ds);
601 err |= __put_user(env->regs[R_EDI], &sc->edi);
602 err |= __put_user(env->regs[R_ESI], &sc->esi);
603 err |= __put_user(env->regs[R_EBP], &sc->ebp);
604 err |= __put_user(env->regs[R_ESP], &sc->esp);
605 err |= __put_user(env->regs[R_EBX], &sc->ebx);
606 err |= __put_user(env->regs[R_EDX], &sc->edx);
607 err |= __put_user(env->regs[R_ECX], &sc->ecx);
608 err |= __put_user(env->regs[R_EAX], &sc->eax);
609 err |= __put_user(env->exception_index, &sc->trapno);
610 err |= __put_user(env->error_code, &sc->err);
611 err |= __put_user(env->eip, &sc->eip);
612 err |= __put_user(env->segs[R_CS].selector, (unsigned int *)&sc->cs);
613 err |= __put_user(env->eflags, &sc->eflags);
614 err |= __put_user(env->regs[R_ESP], &sc->esp_at_signal);
615 err |= __put_user(env->segs[R_SS].selector, (unsigned int *)&sc->ss);
616
617 cpu_x86_fsave(env, (void *)fpstate, 1);
618 fpstate->status = fpstate->sw;
619 err |= __put_user(0xffff, &fpstate->magic);
620 err |= __put_user(fpstate, &sc->fpstate);
621
622 /* non-iBCS2 extensions.. */
623 err |= __put_user(mask, &sc->oldmask);
624 err |= __put_user(env->cr[2], &sc->cr2);
625 return err;
626 }
627
628 /*
629 * Determine which stack to use..
630 */
631
632 static inline void *
633 get_sigframe(struct emulated_sigaction *ka, CPUX86State *env, size_t frame_size)
634 {
635 unsigned long esp;
636
637 /* Default to using normal stack */
638 esp = env->regs[R_ESP];
639 #if 0
640 /* This is the X/Open sanctioned signal stack switching. */
641 if (ka->sa.sa_flags & SA_ONSTACK) {
642 if (sas_ss_flags(esp) == 0)
643 esp = current->sas_ss_sp + current->sas_ss_size;
644 }
645
646 /* This is the legacy signal stack switching. */
647 else
648 #endif
649 if ((env->segs[R_SS].selector & 0xffff) != __USER_DS &&
650 !(ka->sa.sa_flags & TARGET_SA_RESTORER) &&
651 ka->sa.sa_restorer) {
652 esp = (unsigned long) ka->sa.sa_restorer;
653 }
654 return g2h((esp - frame_size) & -8ul);
655 }
656
657 static void setup_frame(int sig, struct emulated_sigaction *ka,
658 target_sigset_t *set, CPUX86State *env)
659 {
660 struct sigframe *frame;
661 int i, err = 0;
662
663 frame = get_sigframe(ka, env, sizeof(*frame));
664
665 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
666 goto give_sigsegv;
667 err |= __put_user((/*current->exec_domain
668 && current->exec_domain->signal_invmap
669 && sig < 32
670 ? current->exec_domain->signal_invmap[sig]
671 : */ sig),
672 &frame->sig);
673 if (err)
674 goto give_sigsegv;
675
676 setup_sigcontext(&frame->sc, &frame->fpstate, env, set->sig[0]);
677 if (err)
678 goto give_sigsegv;
679
680 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
681 if (__put_user(set->sig[i], &frame->extramask[i - 1]))
682 goto give_sigsegv;
683 }
684
685 /* Set up to return from userspace. If provided, use a stub
686 already in userspace. */
687 if (ka->sa.sa_flags & TARGET_SA_RESTORER) {
688 err |= __put_user(ka->sa.sa_restorer, &frame->pretcode);
689 } else {
690 err |= __put_user(frame->retcode, &frame->pretcode);
691 /* This is popl %eax ; movl $,%eax ; int $0x80 */
692 err |= __put_user(0xb858, (short *)(frame->retcode+0));
693 err |= __put_user(TARGET_NR_sigreturn, (int *)(frame->retcode+2));
694 err |= __put_user(0x80cd, (short *)(frame->retcode+6));
695 }
696
697 if (err)
698 goto give_sigsegv;
699
700 /* Set up registers for signal handler */
701 env->regs[R_ESP] = h2g(frame);
702 env->eip = (unsigned long) ka->sa._sa_handler;
703
704 cpu_x86_load_seg(env, R_DS, __USER_DS);
705 cpu_x86_load_seg(env, R_ES, __USER_DS);
706 cpu_x86_load_seg(env, R_SS, __USER_DS);
707 cpu_x86_load_seg(env, R_CS, __USER_CS);
708 env->eflags &= ~TF_MASK;
709
710 return;
711
712 give_sigsegv:
713 if (sig == TARGET_SIGSEGV)
714 ka->sa._sa_handler = TARGET_SIG_DFL;
715 force_sig(TARGET_SIGSEGV /* , current */);
716 }
717
718 static void setup_rt_frame(int sig, struct emulated_sigaction *ka,
719 target_siginfo_t *info,
720 target_sigset_t *set, CPUX86State *env)
721 {
722 struct rt_sigframe *frame;
723 int i, err = 0;
724
725 frame = get_sigframe(ka, env, sizeof(*frame));
726
727 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
728 goto give_sigsegv;
729
730 err |= __put_user((/*current->exec_domain
731 && current->exec_domain->signal_invmap
732 && sig < 32
733 ? current->exec_domain->signal_invmap[sig]
734 : */sig),
735 &frame->sig);
736 err |= __put_user((target_ulong)&frame->info, &frame->pinfo);
737 err |= __put_user((target_ulong)&frame->uc, &frame->puc);
738 err |= copy_siginfo_to_user(&frame->info, info);
739 if (err)
740 goto give_sigsegv;
741
742 /* Create the ucontext. */
743 err |= __put_user(0, &frame->uc.tuc_flags);
744 err |= __put_user(0, &frame->uc.tuc_link);
745 err |= __put_user(/*current->sas_ss_sp*/ 0,
746 &frame->uc.tuc_stack.ss_sp);
747 err |= __put_user(/* sas_ss_flags(regs->esp) */ 0,
748 &frame->uc.tuc_stack.ss_flags);
749 err |= __put_user(/* current->sas_ss_size */ 0,
750 &frame->uc.tuc_stack.ss_size);
751 err |= setup_sigcontext(&frame->uc.tuc_mcontext, &frame->fpstate,
752 env, set->sig[0]);
753 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
754 if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
755 goto give_sigsegv;
756 }
757
758 /* Set up to return from userspace. If provided, use a stub
759 already in userspace. */
760 if (ka->sa.sa_flags & TARGET_SA_RESTORER) {
761 err |= __put_user(ka->sa.sa_restorer, &frame->pretcode);
762 } else {
763 err |= __put_user(frame->retcode, &frame->pretcode);
764 /* This is movl $,%eax ; int $0x80 */
765 err |= __put_user(0xb8, (char *)(frame->retcode+0));
766 err |= __put_user(TARGET_NR_rt_sigreturn, (int *)(frame->retcode+1));
767 err |= __put_user(0x80cd, (short *)(frame->retcode+5));
768 }
769
770 if (err)
771 goto give_sigsegv;
772
773 /* Set up registers for signal handler */
774 env->regs[R_ESP] = (unsigned long) frame;
775 env->eip = (unsigned long) ka->sa._sa_handler;
776
777 cpu_x86_load_seg(env, R_DS, __USER_DS);
778 cpu_x86_load_seg(env, R_ES, __USER_DS);
779 cpu_x86_load_seg(env, R_SS, __USER_DS);
780 cpu_x86_load_seg(env, R_CS, __USER_CS);
781 env->eflags &= ~TF_MASK;
782
783 return;
784
785 give_sigsegv:
786 if (sig == TARGET_SIGSEGV)
787 ka->sa._sa_handler = TARGET_SIG_DFL;
788 force_sig(TARGET_SIGSEGV /* , current */);
789 }
790
791 static int
792 restore_sigcontext(CPUX86State *env, struct target_sigcontext *sc, int *peax)
793 {
794 unsigned int err = 0;
795
796 cpu_x86_load_seg(env, R_GS, lduw(&sc->gs));
797 cpu_x86_load_seg(env, R_FS, lduw(&sc->fs));
798 cpu_x86_load_seg(env, R_ES, lduw(&sc->es));
799 cpu_x86_load_seg(env, R_DS, lduw(&sc->ds));
800
801 env->regs[R_EDI] = ldl(&sc->edi);
802 env->regs[R_ESI] = ldl(&sc->esi);
803 env->regs[R_EBP] = ldl(&sc->ebp);
804 env->regs[R_ESP] = ldl(&sc->esp);
805 env->regs[R_EBX] = ldl(&sc->ebx);
806 env->regs[R_EDX] = ldl(&sc->edx);
807 env->regs[R_ECX] = ldl(&sc->ecx);
808 env->eip = ldl(&sc->eip);
809
810 cpu_x86_load_seg(env, R_CS, lduw(&sc->cs) | 3);
811 cpu_x86_load_seg(env, R_SS, lduw(&sc->ss) | 3);
812
813 {
814 unsigned int tmpflags;
815 tmpflags = ldl(&sc->eflags);
816 env->eflags = (env->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);
817 // regs->orig_eax = -1; /* disable syscall checks */
818 }
819
820 {
821 struct _fpstate * buf;
822 buf = (void *)ldl(&sc->fpstate);
823 if (buf) {
824 #if 0
825 if (verify_area(VERIFY_READ, buf, sizeof(*buf)))
826 goto badframe;
827 #endif
828 cpu_x86_frstor(env, (void *)buf, 1);
829 }
830 }
831
832 *peax = ldl(&sc->eax);
833 return err;
834 #if 0
835 badframe:
836 return 1;
837 #endif
838 }
839
840 long do_sigreturn(CPUX86State *env)
841 {
842 struct sigframe *frame = (struct sigframe *)g2h(env->regs[R_ESP] - 8);
843 target_sigset_t target_set;
844 sigset_t set;
845 int eax, i;
846
847 #if defined(DEBUG_SIGNAL)
848 fprintf(stderr, "do_sigreturn\n");
849 #endif
850 /* set blocked signals */
851 if (__get_user(target_set.sig[0], &frame->sc.oldmask))
852 goto badframe;
853 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
854 if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
855 goto badframe;
856 }
857
858 target_to_host_sigset_internal(&set, &target_set);
859 sigprocmask(SIG_SETMASK, &set, NULL);
860
861 /* restore registers */
862 if (restore_sigcontext(env, &frame->sc, &eax))
863 goto badframe;
864 return eax;
865
866 badframe:
867 force_sig(TARGET_SIGSEGV);
868 return 0;
869 }
870
871 long do_rt_sigreturn(CPUX86State *env)
872 {
873 struct rt_sigframe *frame = (struct rt_sigframe *)g2h(env->regs[R_ESP] - 4);
874 sigset_t set;
875 // stack_t st;
876 int eax;
877
878 #if 0
879 if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
880 goto badframe;
881 #endif
882 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
883 sigprocmask(SIG_SETMASK, &set, NULL);
884
885 if (restore_sigcontext(env, &frame->uc.tuc_mcontext, &eax))
886 goto badframe;
887
888 #if 0
889 if (__copy_from_user(&st, &frame->uc.tuc_stack, sizeof(st)))
890 goto badframe;
891 /* It is more difficult to avoid calling this function than to
892 call it and ignore errors. */
893 do_sigaltstack(&st, NULL, regs->esp);
894 #endif
895 return eax;
896
897 badframe:
898 force_sig(TARGET_SIGSEGV);
899 return 0;
900 }
901
902 #elif defined(TARGET_ARM)
903
904 struct target_sigcontext {
905 target_ulong trap_no;
906 target_ulong error_code;
907 target_ulong oldmask;
908 target_ulong arm_r0;
909 target_ulong arm_r1;
910 target_ulong arm_r2;
911 target_ulong arm_r3;
912 target_ulong arm_r4;
913 target_ulong arm_r5;
914 target_ulong arm_r6;
915 target_ulong arm_r7;
916 target_ulong arm_r8;
917 target_ulong arm_r9;
918 target_ulong arm_r10;
919 target_ulong arm_fp;
920 target_ulong arm_ip;
921 target_ulong arm_sp;
922 target_ulong arm_lr;
923 target_ulong arm_pc;
924 target_ulong arm_cpsr;
925 target_ulong fault_address;
926 };
927
928 typedef struct target_sigaltstack {
929 target_ulong ss_sp;
930 int ss_flags;
931 target_ulong ss_size;
932 } target_stack_t;
933
934 struct target_ucontext {
935 target_ulong tuc_flags;
936 target_ulong tuc_link;
937 target_stack_t tuc_stack;
938 struct target_sigcontext tuc_mcontext;
939 target_sigset_t tuc_sigmask; /* mask last for extensibility */
940 };
941
942 struct sigframe
943 {
944 struct target_sigcontext sc;
945 target_ulong extramask[TARGET_NSIG_WORDS-1];
946 target_ulong retcode;
947 };
948
949 struct rt_sigframe
950 {
951 struct target_siginfo *pinfo;
952 void *puc;
953 struct target_siginfo info;
954 struct target_ucontext uc;
955 target_ulong retcode;
956 };
957
958 #define TARGET_CONFIG_CPU_32 1
959
960 /*
961 * For ARM syscalls, we encode the syscall number into the instruction.
962 */
963 #define SWI_SYS_SIGRETURN (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE))
964 #define SWI_SYS_RT_SIGRETURN (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE))
965
966 /*
967 * For Thumb syscalls, we pass the syscall number via r7. We therefore
968 * need two 16-bit instructions.
969 */
970 #define SWI_THUMB_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn))
971 #define SWI_THUMB_RT_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn))
972
973 static const target_ulong retcodes[4] = {
974 SWI_SYS_SIGRETURN, SWI_THUMB_SIGRETURN,
975 SWI_SYS_RT_SIGRETURN, SWI_THUMB_RT_SIGRETURN
976 };
977
978
979 #define __put_user_error(x,p,e) __put_user(x, p)
980 #define __get_user_error(x,p,e) __get_user(x, p)
981
982 static inline int valid_user_regs(CPUState *regs)
983 {
984 return 1;
985 }
986
987 static int
988 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
989 CPUState *env, unsigned long mask)
990 {
991 int err = 0;
992
993 __put_user_error(env->regs[0], &sc->arm_r0, err);
994 __put_user_error(env->regs[1], &sc->arm_r1, err);
995 __put_user_error(env->regs[2], &sc->arm_r2, err);
996 __put_user_error(env->regs[3], &sc->arm_r3, err);
997 __put_user_error(env->regs[4], &sc->arm_r4, err);
998 __put_user_error(env->regs[5], &sc->arm_r5, err);
999 __put_user_error(env->regs[6], &sc->arm_r6, err);
1000 __put_user_error(env->regs[7], &sc->arm_r7, err);
1001 __put_user_error(env->regs[8], &sc->arm_r8, err);
1002 __put_user_error(env->regs[9], &sc->arm_r9, err);
1003 __put_user_error(env->regs[10], &sc->arm_r10, err);
1004 __put_user_error(env->regs[11], &sc->arm_fp, err);
1005 __put_user_error(env->regs[12], &sc->arm_ip, err);
1006 __put_user_error(env->regs[13], &sc->arm_sp, err);
1007 __put_user_error(env->regs[14], &sc->arm_lr, err);
1008 __put_user_error(env->regs[15], &sc->arm_pc, err);
1009 #ifdef TARGET_CONFIG_CPU_32
1010 __put_user_error(cpsr_read(env), &sc->arm_cpsr, err);
1011 #endif
1012
1013 __put_user_error(/* current->thread.trap_no */ 0, &sc->trap_no, err);
1014 __put_user_error(/* current->thread.error_code */ 0, &sc->error_code, err);
1015 __put_user_error(/* current->thread.address */ 0, &sc->fault_address, err);
1016 __put_user_error(mask, &sc->oldmask, err);
1017
1018 return err;
1019 }
1020
1021 static inline void *
1022 get_sigframe(struct emulated_sigaction *ka, CPUState *regs, int framesize)
1023 {
1024 unsigned long sp = regs->regs[13];
1025
1026 #if 0
1027 /*
1028 * This is the X/Open sanctioned signal stack switching.
1029 */
1030 if ((ka->sa.sa_flags & SA_ONSTACK) && !sas_ss_flags(sp))
1031 sp = current->sas_ss_sp + current->sas_ss_size;
1032 #endif
1033 /*
1034 * ATPCS B01 mandates 8-byte alignment
1035 */
1036 return g2h((sp - framesize) & ~7);
1037 }
1038
1039 static int
1040 setup_return(CPUState *env, struct emulated_sigaction *ka,
1041 target_ulong *rc, void *frame, int usig)
1042 {
1043 target_ulong handler = (target_ulong)ka->sa._sa_handler;
1044 target_ulong retcode;
1045 int thumb = 0;
1046 #if defined(TARGET_CONFIG_CPU_32)
1047 #if 0
1048 target_ulong cpsr = env->cpsr;
1049
1050 /*
1051 * Maybe we need to deliver a 32-bit signal to a 26-bit task.
1052 */
1053 if (ka->sa.sa_flags & SA_THIRTYTWO)
1054 cpsr = (cpsr & ~MODE_MASK) | USR_MODE;
1055
1056 #ifdef CONFIG_ARM_THUMB
1057 if (elf_hwcap & HWCAP_THUMB) {
1058 /*
1059 * The LSB of the handler determines if we're going to
1060 * be using THUMB or ARM mode for this signal handler.
1061 */
1062 thumb = handler & 1;
1063
1064 if (thumb)
1065 cpsr |= T_BIT;
1066 else
1067 cpsr &= ~T_BIT;
1068 }
1069 #endif
1070 #endif
1071 #endif /* TARGET_CONFIG_CPU_32 */
1072
1073 if (ka->sa.sa_flags & TARGET_SA_RESTORER) {
1074 retcode = (target_ulong)ka->sa.sa_restorer;
1075 } else {
1076 unsigned int idx = thumb;
1077
1078 if (ka->sa.sa_flags & TARGET_SA_SIGINFO)
1079 idx += 2;
1080
1081 if (__put_user(retcodes[idx], rc))
1082 return 1;
1083 #if 0
1084 flush_icache_range((target_ulong)rc,
1085 (target_ulong)(rc + 1));
1086 #endif
1087 retcode = ((target_ulong)rc) + thumb;
1088 }
1089
1090 env->regs[0] = usig;
1091 env->regs[13] = h2g(frame);
1092 env->regs[14] = retcode;
1093 env->regs[15] = handler & (thumb ? ~1 : ~3);
1094
1095 #if 0
1096 #ifdef TARGET_CONFIG_CPU_32
1097 env->cpsr = cpsr;
1098 #endif
1099 #endif
1100
1101 return 0;
1102 }
1103
1104 static void setup_frame(int usig, struct emulated_sigaction *ka,
1105 target_sigset_t *set, CPUState *regs)
1106 {
1107 struct sigframe *frame = get_sigframe(ka, regs, sizeof(*frame));
1108 int i, err = 0;
1109
1110 err |= setup_sigcontext(&frame->sc, /*&frame->fpstate,*/ regs, set->sig[0]);
1111
1112 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1113 if (__put_user(set->sig[i], &frame->extramask[i - 1]))
1114 return;
1115 }
1116
1117 if (err == 0)
1118 err = setup_return(regs, ka, &frame->retcode, frame, usig);
1119 // return err;
1120 }
1121
1122 static void setup_rt_frame(int usig, struct emulated_sigaction *ka,
1123 target_siginfo_t *info,
1124 target_sigset_t *set, CPUState *env)
1125 {
1126 struct rt_sigframe *frame = get_sigframe(ka, env, sizeof(*frame));
1127 int i, err = 0;
1128
1129 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
1130 return /* 1 */;
1131
1132 __put_user_error(&frame->info, (target_ulong *)&frame->pinfo, err);
1133 __put_user_error(&frame->uc, (target_ulong *)&frame->puc, err);
1134 err |= copy_siginfo_to_user(&frame->info, info);
1135
1136 /* Clear all the bits of the ucontext we don't use. */
1137 memset(&frame->uc, 0, offsetof(struct target_ucontext, tuc_mcontext));
1138
1139 err |= setup_sigcontext(&frame->uc.tuc_mcontext, /*&frame->fpstate,*/
1140 env, set->sig[0]);
1141 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1142 if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
1143 return;
1144 }
1145
1146 if (err == 0)
1147 err = setup_return(env, ka, &frame->retcode, frame, usig);
1148
1149 if (err == 0) {
1150 /*
1151 * For realtime signals we must also set the second and third
1152 * arguments for the signal handler.
1153 * -- Peter Maydell <pmaydell@chiark.greenend.org.uk> 2000-12-06
1154 */
1155 env->regs[1] = (target_ulong)frame->pinfo;
1156 env->regs[2] = (target_ulong)frame->puc;
1157 }
1158
1159 // return err;
1160 }
1161
1162 static int
1163 restore_sigcontext(CPUState *env, struct target_sigcontext *sc)
1164 {
1165 int err = 0;
1166 uint32_t cpsr;
1167
1168 __get_user_error(env->regs[0], &sc->arm_r0, err);
1169 __get_user_error(env->regs[1], &sc->arm_r1, err);
1170 __get_user_error(env->regs[2], &sc->arm_r2, err);
1171 __get_user_error(env->regs[3], &sc->arm_r3, err);
1172 __get_user_error(env->regs[4], &sc->arm_r4, err);
1173 __get_user_error(env->regs[5], &sc->arm_r5, err);
1174 __get_user_error(env->regs[6], &sc->arm_r6, err);
1175 __get_user_error(env->regs[7], &sc->arm_r7, err);
1176 __get_user_error(env->regs[8], &sc->arm_r8, err);
1177 __get_user_error(env->regs[9], &sc->arm_r9, err);
1178 __get_user_error(env->regs[10], &sc->arm_r10, err);
1179 __get_user_error(env->regs[11], &sc->arm_fp, err);
1180 __get_user_error(env->regs[12], &sc->arm_ip, err);
1181 __get_user_error(env->regs[13], &sc->arm_sp, err);
1182 __get_user_error(env->regs[14], &sc->arm_lr, err);
1183 __get_user_error(env->regs[15], &sc->arm_pc, err);
1184 #ifdef TARGET_CONFIG_CPU_32
1185 __get_user_error(cpsr, &sc->arm_cpsr, err);
1186 cpsr_write(env, cpsr, 0xffffffff);
1187 #endif
1188
1189 err |= !valid_user_regs(env);
1190
1191 return err;
1192 }
1193
1194 long do_sigreturn(CPUState *env)
1195 {
1196 struct sigframe *frame;
1197 target_sigset_t set;
1198 sigset_t host_set;
1199 int i;
1200
1201 /*
1202 * Since we stacked the signal on a 64-bit boundary,
1203 * then 'sp' should be word aligned here. If it's
1204 * not, then the user is trying to mess with us.
1205 */
1206 if (env->regs[13] & 7)
1207 goto badframe;
1208
1209 frame = (struct sigframe *)g2h(env->regs[13]);
1210
1211 #if 0
1212 if (verify_area(VERIFY_READ, frame, sizeof (*frame)))
1213 goto badframe;
1214 #endif
1215 if (__get_user(set.sig[0], &frame->sc.oldmask))
1216 goto badframe;
1217 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1218 if (__get_user(set.sig[i], &frame->extramask[i - 1]))
1219 goto badframe;
1220 }
1221
1222 target_to_host_sigset_internal(&host_set, &set);
1223 sigprocmask(SIG_SETMASK, &host_set, NULL);
1224
1225 if (restore_sigcontext(env, &frame->sc))
1226 goto badframe;
1227
1228 #if 0
1229 /* Send SIGTRAP if we're single-stepping */
1230 if (ptrace_cancel_bpt(current))
1231 send_sig(SIGTRAP, current, 1);
1232 #endif
1233 return env->regs[0];
1234
1235 badframe:
1236 force_sig(SIGSEGV /* , current */);
1237 return 0;
1238 }
1239
1240 long do_rt_sigreturn(CPUState *env)
1241 {
1242 struct rt_sigframe *frame;
1243 sigset_t host_set;
1244
1245 /*
1246 * Since we stacked the signal on a 64-bit boundary,
1247 * then 'sp' should be word aligned here. If it's
1248 * not, then the user is trying to mess with us.
1249 */
1250 if (env->regs[13] & 7)
1251 goto badframe;
1252
1253 frame = (struct rt_sigframe *)env->regs[13];
1254
1255 #if 0
1256 if (verify_area(VERIFY_READ, frame, sizeof (*frame)))
1257 goto badframe;
1258 #endif
1259 target_to_host_sigset(&host_set, &frame->uc.tuc_sigmask);
1260 sigprocmask(SIG_SETMASK, &host_set, NULL);
1261
1262 if (restore_sigcontext(env, &frame->uc.tuc_mcontext))
1263 goto badframe;
1264
1265 #if 0
1266 /* Send SIGTRAP if we're single-stepping */
1267 if (ptrace_cancel_bpt(current))
1268 send_sig(SIGTRAP, current, 1);
1269 #endif
1270 return env->regs[0];
1271
1272 badframe:
1273 force_sig(SIGSEGV /* , current */);
1274 return 0;
1275 }
1276
1277 #elif defined(TARGET_SPARC)
1278
1279 #define __SUNOS_MAXWIN 31
1280
1281 /* This is what SunOS does, so shall I. */
1282 struct target_sigcontext {
1283 target_ulong sigc_onstack; /* state to restore */
1284
1285 target_ulong sigc_mask; /* sigmask to restore */
1286 target_ulong sigc_sp; /* stack pointer */
1287 target_ulong sigc_pc; /* program counter */
1288 target_ulong sigc_npc; /* next program counter */
1289 target_ulong sigc_psr; /* for condition codes etc */
1290 target_ulong sigc_g1; /* User uses these two registers */
1291 target_ulong sigc_o0; /* within the trampoline code. */
1292
1293 /* Now comes information regarding the users window set
1294 * at the time of the signal.
1295 */
1296 target_ulong sigc_oswins; /* outstanding windows */
1297
1298 /* stack ptrs for each regwin buf */
1299 char *sigc_spbuf[__SUNOS_MAXWIN];
1300
1301 /* Windows to restore after signal */
1302 struct {
1303 target_ulong locals[8];
1304 target_ulong ins[8];
1305 } sigc_wbuf[__SUNOS_MAXWIN];
1306 };
1307 /* A Sparc stack frame */
1308 struct sparc_stackf {
1309 target_ulong locals[8];
1310 target_ulong ins[6];
1311 struct sparc_stackf *fp;
1312 target_ulong callers_pc;
1313 char *structptr;
1314 target_ulong xargs[6];
1315 target_ulong xxargs[1];
1316 };
1317
1318 typedef struct {
1319 struct {
1320 target_ulong psr;
1321 target_ulong pc;
1322 target_ulong npc;
1323 target_ulong y;
1324 target_ulong u_regs[16]; /* globals and ins */
1325 } si_regs;
1326 int si_mask;
1327 } __siginfo_t;
1328
1329 typedef struct {
1330 unsigned long si_float_regs [32];
1331 unsigned long si_fsr;
1332 unsigned long si_fpqdepth;
1333 struct {
1334 unsigned long *insn_addr;
1335 unsigned long insn;
1336 } si_fpqueue [16];
1337 } qemu_siginfo_fpu_t;
1338
1339
1340 struct target_signal_frame {
1341 struct sparc_stackf ss;
1342 __siginfo_t info;
1343 qemu_siginfo_fpu_t *fpu_save;
1344 target_ulong insns[2] __attribute__ ((aligned (8)));
1345 target_ulong extramask[TARGET_NSIG_WORDS - 1];
1346 target_ulong extra_size; /* Should be 0 */
1347 qemu_siginfo_fpu_t fpu_state;
1348 };
1349 struct target_rt_signal_frame {
1350 struct sparc_stackf ss;
1351 siginfo_t info;
1352 target_ulong regs[20];
1353 sigset_t mask;
1354 qemu_siginfo_fpu_t *fpu_save;
1355 unsigned int insns[2];
1356 stack_t stack;
1357 unsigned int extra_size; /* Should be 0 */
1358 qemu_siginfo_fpu_t fpu_state;
1359 };
1360
1361 #define UREG_O0 16
1362 #define UREG_O6 22
1363 #define UREG_I0 0
1364 #define UREG_I1 1
1365 #define UREG_I2 2
1366 #define UREG_I6 6
1367 #define UREG_I7 7
1368 #define UREG_L0 8
1369 #define UREG_FP UREG_I6
1370 #define UREG_SP UREG_O6
1371
1372 static inline void *get_sigframe(struct emulated_sigaction *sa, CPUState *env, unsigned long framesize)
1373 {
1374 unsigned long sp;
1375
1376 sp = env->regwptr[UREG_FP];
1377 #if 0
1378
1379 /* This is the X/Open sanctioned signal stack switching. */
1380 if (sa->sa_flags & TARGET_SA_ONSTACK) {
1381 if (!on_sig_stack(sp) && !((current->sas_ss_sp + current->sas_ss_size) & 7))
1382 sp = current->sas_ss_sp + current->sas_ss_size;
1383 }
1384 #endif
1385 return g2h(sp - framesize);
1386 }
1387
1388 static int
1389 setup___siginfo(__siginfo_t *si, CPUState *env, target_ulong mask)
1390 {
1391 int err = 0, i;
1392
1393 err |= __put_user(env->psr, &si->si_regs.psr);
1394 err |= __put_user(env->pc, &si->si_regs.pc);
1395 err |= __put_user(env->npc, &si->si_regs.npc);
1396 err |= __put_user(env->y, &si->si_regs.y);
1397 for (i=0; i < 8; i++) {
1398 err |= __put_user(env->gregs[i], &si->si_regs.u_regs[i]);
1399 }
1400 for (i=0; i < 8; i++) {
1401 err |= __put_user(env->regwptr[UREG_I0 + i], &si->si_regs.u_regs[i+8]);
1402 }
1403 err |= __put_user(mask, &si->si_mask);
1404 return err;
1405 }
1406
1407 #if 0
1408 static int
1409 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
1410 CPUState *env, unsigned long mask)
1411 {
1412 int err = 0;
1413
1414 err |= __put_user(mask, &sc->sigc_mask);
1415 err |= __put_user(env->regwptr[UREG_SP], &sc->sigc_sp);
1416 err |= __put_user(env->pc, &sc->sigc_pc);
1417 err |= __put_user(env->npc, &sc->sigc_npc);
1418 err |= __put_user(env->psr, &sc->sigc_psr);
1419 err |= __put_user(env->gregs[1], &sc->sigc_g1);
1420 err |= __put_user(env->regwptr[UREG_O0], &sc->sigc_o0);
1421
1422 return err;
1423 }
1424 #endif
1425 #define NF_ALIGNEDSZ (((sizeof(struct target_signal_frame) + 7) & (~7)))
1426
1427 static void setup_frame(int sig, struct emulated_sigaction *ka,
1428 target_sigset_t *set, CPUState *env)
1429 {
1430 struct target_signal_frame *sf;
1431 int sigframe_size, err, i;
1432
1433 /* 1. Make sure everything is clean */
1434 //synchronize_user_stack();
1435
1436 sigframe_size = NF_ALIGNEDSZ;
1437
1438 sf = (struct target_signal_frame *)
1439 get_sigframe(ka, env, sigframe_size);
1440
1441 //fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
1442 #if 0
1443 if (invalid_frame_pointer(sf, sigframe_size))
1444 goto sigill_and_return;
1445 #endif
1446 /* 2. Save the current process state */
1447 err = setup___siginfo(&sf->info, env, set->sig[0]);
1448 err |= __put_user(0, &sf->extra_size);
1449
1450 //err |= save_fpu_state(regs, &sf->fpu_state);
1451 //err |= __put_user(&sf->fpu_state, &sf->fpu_save);
1452
1453 err |= __put_user(set->sig[0], &sf->info.si_mask);
1454 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
1455 err |= __put_user(set->sig[i + 1], &sf->extramask[i]);
1456 }
1457
1458 for (i = 0; i < 8; i++) {
1459 err |= __put_user(env->regwptr[i + UREG_L0], &sf->ss.locals[i]);
1460 }
1461 for (i = 0; i < 8; i++) {
1462 err |= __put_user(env->regwptr[i + UREG_I0], &sf->ss.ins[i]);
1463 }
1464 if (err)
1465 goto sigsegv;
1466
1467 /* 3. signal handler back-trampoline and parameters */
1468 env->regwptr[UREG_FP] = h2g(sf);
1469 env->regwptr[UREG_I0] = sig;
1470 env->regwptr[UREG_I1] = h2g(&sf->info);
1471 env->regwptr[UREG_I2] = h2g(&sf->info);
1472
1473 /* 4. signal handler */
1474 env->pc = (unsigned long) ka->sa._sa_handler;
1475 env->npc = (env->pc + 4);
1476 /* 5. return to kernel instructions */
1477 if (ka->sa.sa_restorer)
1478 env->regwptr[UREG_I7] = (unsigned long)ka->sa.sa_restorer;
1479 else {
1480 env->regwptr[UREG_I7] = h2g(&(sf->insns[0]) - 2);
1481
1482 /* mov __NR_sigreturn, %g1 */
1483 err |= __put_user(0x821020d8, &sf->insns[0]);
1484
1485 /* t 0x10 */
1486 err |= __put_user(0x91d02010, &sf->insns[1]);
1487 if (err)
1488 goto sigsegv;
1489
1490 /* Flush instruction space. */
1491 //flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
1492 // tb_flush(env);
1493 }
1494 return;
1495
1496 //sigill_and_return:
1497 force_sig(TARGET_SIGILL);
1498 sigsegv:
1499 //fprintf(stderr, "force_sig\n");
1500 force_sig(TARGET_SIGSEGV);
1501 }
1502 static inline int
1503 restore_fpu_state(CPUState *env, qemu_siginfo_fpu_t *fpu)
1504 {
1505 int err;
1506 #if 0
1507 #ifdef CONFIG_SMP
1508 if (current->flags & PF_USEDFPU)
1509 regs->psr &= ~PSR_EF;
1510 #else
1511 if (current == last_task_used_math) {
1512 last_task_used_math = 0;
1513 regs->psr &= ~PSR_EF;
1514 }
1515 #endif
1516 current->used_math = 1;
1517 current->flags &= ~PF_USEDFPU;
1518 #endif
1519 #if 0
1520 if (verify_area (VERIFY_READ, fpu, sizeof(*fpu)))
1521 return -EFAULT;
1522 #endif
1523
1524 err = __copy_from_user(&env->fpr[0], &fpu->si_float_regs[0],
1525 (sizeof(unsigned long) * 32));
1526 err |= __get_user(env->fsr, &fpu->si_fsr);
1527 #if 0
1528 err |= __get_user(current->thread.fpqdepth, &fpu->si_fpqdepth);
1529 if (current->thread.fpqdepth != 0)
1530 err |= __copy_from_user(&current->thread.fpqueue[0],
1531 &fpu->si_fpqueue[0],
1532 ((sizeof(unsigned long) +
1533 (sizeof(unsigned long *)))*16));
1534 #endif
1535 return err;
1536 }
1537
1538
1539 static void setup_rt_frame(int sig, struct emulated_sigaction *ka,
1540 target_siginfo_t *info,
1541 target_sigset_t *set, CPUState *env)
1542 {
1543 fprintf(stderr, "setup_rt_frame: not implemented\n");
1544 }
1545
1546 long do_sigreturn(CPUState *env)
1547 {
1548 struct target_signal_frame *sf;
1549 uint32_t up_psr, pc, npc;
1550 target_sigset_t set;
1551 sigset_t host_set;
1552 target_ulong fpu_save;
1553 int err, i;
1554
1555 sf = (struct target_signal_frame *)g2h(env->regwptr[UREG_FP]);
1556 #if 0
1557 fprintf(stderr, "sigreturn\n");
1558 fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
1559 #endif
1560 //cpu_dump_state(env, stderr, fprintf, 0);
1561
1562 /* 1. Make sure we are not getting garbage from the user */
1563 #if 0
1564 if (verify_area (VERIFY_READ, sf, sizeof (*sf)))
1565 goto segv_and_exit;
1566 #endif
1567
1568 if (((uint) sf) & 3)
1569 goto segv_and_exit;
1570
1571 err = __get_user(pc, &sf->info.si_regs.pc);
1572 err |= __get_user(npc, &sf->info.si_regs.npc);
1573
1574 if ((pc | npc) & 3)
1575 goto segv_and_exit;
1576
1577 /* 2. Restore the state */
1578 err |= __get_user(up_psr, &sf->info.si_regs.psr);
1579
1580 /* User can only change condition codes and FPU enabling in %psr. */
1581 env->psr = (up_psr & (PSR_ICC /* | PSR_EF */))
1582 | (env->psr & ~(PSR_ICC /* | PSR_EF */));
1583
1584 env->pc = pc;
1585 env->npc = npc;
1586 err |= __get_user(env->y, &sf->info.si_regs.y);
1587 for (i=0; i < 8; i++) {
1588 err |= __get_user(env->gregs[i], &sf->info.si_regs.u_regs[i]);
1589 }
1590 for (i=0; i < 8; i++) {
1591 err |= __get_user(env->regwptr[i + UREG_I0], &sf->info.si_regs.u_regs[i+8]);
1592 }
1593
1594 err |= __get_user(fpu_save, (target_ulong *)&sf->fpu_save);
1595
1596 //if (fpu_save)
1597 // err |= restore_fpu_state(env, fpu_save);
1598
1599 /* This is pretty much atomic, no amount locking would prevent
1600 * the races which exist anyways.
1601 */
1602 err |= __get_user(set.sig[0], &sf->info.si_mask);
1603 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1604 err |= (__get_user(set.sig[i], &sf->extramask[i - 1]));
1605 }
1606
1607 target_to_host_sigset_internal(&host_set, &set);
1608 sigprocmask(SIG_SETMASK, &host_set, NULL);
1609
1610 if (err)
1611 goto segv_and_exit;
1612
1613 return env->regwptr[0];
1614
1615 segv_and_exit:
1616 force_sig(TARGET_SIGSEGV);
1617 }
1618
1619 long do_rt_sigreturn(CPUState *env)
1620 {
1621 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
1622 return -ENOSYS;
1623 }
1624
1625 #elif defined(TARGET_MIPS)
1626
1627 struct target_sigcontext {
1628 uint32_t sc_regmask; /* Unused */
1629 uint32_t sc_status;
1630 uint64_t sc_pc;
1631 uint64_t sc_regs[32];
1632 uint64_t sc_fpregs[32];
1633 uint32_t sc_ownedfp; /* Unused */
1634 uint32_t sc_fpc_csr;
1635 uint32_t sc_fpc_eir; /* Unused */
1636 uint32_t sc_used_math;
1637 uint32_t sc_dsp; /* dsp status, was sc_ssflags */
1638 uint64_t sc_mdhi;
1639 uint64_t sc_mdlo;
1640 target_ulong sc_hi1; /* Was sc_cause */
1641 target_ulong sc_lo1; /* Was sc_badvaddr */
1642 target_ulong sc_hi2; /* Was sc_sigset[4] */
1643 target_ulong sc_lo2;
1644 target_ulong sc_hi3;
1645 target_ulong sc_lo3;
1646 };
1647
1648 struct sigframe {
1649 uint32_t sf_ass[4]; /* argument save space for o32 */
1650 uint32_t sf_code[2]; /* signal trampoline */
1651 struct target_sigcontext sf_sc;
1652 target_sigset_t sf_mask;
1653 };
1654
1655 /* Install trampoline to jump back from signal handler */
1656 static inline int install_sigtramp(unsigned int *tramp, unsigned int syscall)
1657 {
1658 int err;
1659
1660 /*
1661 * Set up the return code ...
1662 *
1663 * li v0, __NR__foo_sigreturn
1664 * syscall
1665 */
1666
1667 err = __put_user(0x24020000 + syscall, tramp + 0);
1668 err |= __put_user(0x0000000c , tramp + 1);
1669 /* flush_cache_sigtramp((unsigned long) tramp); */
1670 return err;
1671 }
1672
1673 static inline int
1674 setup_sigcontext(CPUState *regs, struct target_sigcontext *sc)
1675 {
1676 int err = 0;
1677
1678 err |= __put_user(regs->PC, &sc->sc_pc);
1679
1680 #define save_gp_reg(i) do { \
1681 err |= __put_user(regs->gpr[i], &sc->sc_regs[i]); \
1682 } while(0)
1683 __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2);
1684 save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
1685 save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
1686 save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
1687 save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
1688 save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
1689 save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
1690 save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
1691 save_gp_reg(31);
1692 #undef save_gp_reg
1693
1694 err |= __put_user(regs->HI, &sc->sc_mdhi);
1695 err |= __put_user(regs->LO, &sc->sc_mdlo);
1696
1697 /* Not used yet, but might be useful if we ever have DSP suppport */
1698 #if 0
1699 if (cpu_has_dsp) {
1700 err |= __put_user(mfhi1(), &sc->sc_hi1);
1701 err |= __put_user(mflo1(), &sc->sc_lo1);
1702 err |= __put_user(mfhi2(), &sc->sc_hi2);
1703 err |= __put_user(mflo2(), &sc->sc_lo2);
1704 err |= __put_user(mfhi3(), &sc->sc_hi3);
1705 err |= __put_user(mflo3(), &sc->sc_lo3);
1706 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
1707 }
1708 /* same with 64 bit */
1709 #ifdef CONFIG_64BIT
1710 err |= __put_user(regs->hi, &sc->sc_hi[0]);
1711 err |= __put_user(regs->lo, &sc->sc_lo[0]);
1712 if (cpu_has_dsp) {
1713 err |= __put_user(mfhi1(), &sc->sc_hi[1]);
1714 err |= __put_user(mflo1(), &sc->sc_lo[1]);
1715 err |= __put_user(mfhi2(), &sc->sc_hi[2]);
1716 err |= __put_user(mflo2(), &sc->sc_lo[2]);
1717 err |= __put_user(mfhi3(), &sc->sc_hi[3]);
1718 err |= __put_user(mflo3(), &sc->sc_lo[3]);
1719 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
1720 }
1721 #endif
1722
1723
1724 #endif
1725
1726
1727 #if 0
1728 err |= __put_user(!!used_math(), &sc->sc_used_math);
1729
1730 if (!used_math())
1731 goto out;
1732
1733 /*
1734 * Save FPU state to signal context. Signal handler will "inherit"
1735 * current FPU state.
1736 */
1737 preempt_disable();
1738
1739 if (!is_fpu_owner()) {
1740 own_fpu();
1741 restore_fp(current);
1742 }
1743 err |= save_fp_context(sc);
1744
1745 preempt_enable();
1746 out:
1747 #endif
1748 return err;
1749 }
1750
1751 static inline int
1752 restore_sigcontext(CPUState *regs, struct target_sigcontext *sc)
1753 {
1754 int err = 0;
1755
1756 err |= __get_user(regs->CP0_EPC, &sc->sc_pc);
1757
1758 err |= __get_user(regs->HI, &sc->sc_mdhi);
1759 err |= __get_user(regs->LO, &sc->sc_mdlo);
1760
1761 #define restore_gp_reg(i) do { \
1762 err |= __get_user(regs->gpr[i], &sc->sc_regs[i]); \
1763 } while(0)
1764 restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
1765 restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
1766 restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
1767 restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
1768 restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
1769 restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
1770 restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
1771 restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
1772 restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
1773 restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
1774 restore_gp_reg(31);
1775 #undef restore_gp_reg
1776
1777 #if 0
1778 if (cpu_has_dsp) {
1779 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
1780 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
1781 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
1782 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
1783 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
1784 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
1785 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
1786 }
1787 #ifdef CONFIG_64BIT
1788 err |= __get_user(regs->hi, &sc->sc_hi[0]);
1789 err |= __get_user(regs->lo, &sc->sc_lo[0]);
1790 if (cpu_has_dsp) {
1791 err |= __get_user(treg, &sc->sc_hi[1]); mthi1(treg);
1792 err |= __get_user(treg, &sc->sc_lo[1]); mthi1(treg);
1793 err |= __get_user(treg, &sc->sc_hi[2]); mthi2(treg);
1794 err |= __get_user(treg, &sc->sc_lo[2]); mthi2(treg);
1795 err |= __get_user(treg, &sc->sc_hi[3]); mthi3(treg);
1796 err |= __get_user(treg, &sc->sc_lo[3]); mthi3(treg);
1797 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
1798 }
1799 #endif
1800
1801 err |= __get_user(used_math, &sc->sc_used_math);
1802 conditional_used_math(used_math);
1803
1804 preempt_disable();
1805
1806 if (used_math()) {
1807 /* restore fpu context if we have used it before */
1808 own_fpu();
1809 err |= restore_fp_context(sc);
1810 } else {
1811 /* signal handler may have used FPU. Give it up. */
1812 lose_fpu();
1813 }
1814
1815 preempt_enable();
1816 #endif
1817 return err;
1818 }
1819 /*
1820 * Determine which stack to use..
1821 */
1822 static inline void *
1823 get_sigframe(struct emulated_sigaction *ka, CPUState *regs, size_t frame_size)
1824 {
1825 unsigned long sp;
1826
1827 /* Default to using normal stack */
1828 sp = regs->gpr[29];
1829
1830 /*
1831 * FPU emulator may have it's own trampoline active just
1832 * above the user stack, 16-bytes before the next lowest
1833 * 16 byte boundary. Try to avoid trashing it.
1834 */
1835 sp -= 32;
1836
1837 #if 0
1838 /* This is the X/Open sanctioned signal stack switching. */
1839 if ((ka->sa.sa_flags & SA_ONSTACK) && (sas_ss_flags (sp) == 0))
1840 sp = current->sas_ss_sp + current->sas_ss_size;
1841 #endif
1842
1843 return g2h((sp - frame_size) & ~7);
1844 }
1845
1846 static void setup_frame(int sig, struct emulated_sigaction * ka,
1847 target_sigset_t *set, CPUState *regs)
1848 {
1849 struct sigframe *frame;
1850 int i;
1851
1852 frame = get_sigframe(ka, regs, sizeof(*frame));
1853 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
1854 goto give_sigsegv;
1855
1856 install_sigtramp(frame->sf_code, TARGET_NR_sigreturn);
1857
1858 if(setup_sigcontext(regs, &frame->sf_sc))
1859 goto give_sigsegv;
1860
1861 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1862 if(__put_user(set->sig[i], &frame->sf_mask.sig[i]))
1863 goto give_sigsegv;
1864 }
1865
1866 /*
1867 * Arguments to signal handler:
1868 *
1869 * a0 = signal number
1870 * a1 = 0 (should be cause)
1871 * a2 = pointer to struct sigcontext
1872 *
1873 * $25 and PC point to the signal handler, $29 points to the
1874 * struct sigframe.
1875 */
1876 regs->gpr[ 4] = sig;
1877 regs->gpr[ 5] = 0;
1878 regs->gpr[ 6] = h2g(&frame->sf_sc);
1879 regs->gpr[29] = h2g(frame);
1880 regs->gpr[31] = h2g(frame->sf_code);
1881 /* The original kernel code sets CP0_EPC to the handler
1882 * since it returns to userland using eret
1883 * we cannot do this here, and we must set PC directly */
1884 regs->PC = regs->gpr[25] = ka->sa._sa_handler;
1885 return;
1886
1887 give_sigsegv:
1888 force_sig(TARGET_SIGSEGV/*, current*/);
1889 return;
1890 }
1891
1892 long do_sigreturn(CPUState *regs)
1893 {
1894 struct sigframe *frame;
1895 sigset_t blocked;
1896 target_sigset_t target_set;
1897 int i;
1898
1899 #if defined(DEBUG_SIGNAL)
1900 fprintf(stderr, "do_sigreturn\n");
1901 #endif
1902 frame = (struct sigframe *) regs->gpr[29];
1903 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
1904 goto badframe;
1905
1906 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1907 if(__get_user(target_set.sig[i], &frame->sf_mask.sig[i]))
1908 goto badframe;
1909 }
1910
1911 target_to_host_sigset_internal(&blocked, &target_set);
1912 sigprocmask(SIG_SETMASK, &blocked, NULL);
1913
1914 if (restore_sigcontext(regs, &frame->sf_sc))
1915 goto badframe;
1916
1917 #if 0
1918 /*
1919 * Don't let your children do this ...
1920 */
1921 __asm__ __volatile__(
1922 "move\t$29, %0\n\t"
1923 "j\tsyscall_exit"
1924 :/* no outputs */
1925 :"r" (&regs));
1926 /* Unreached */
1927 #endif
1928
1929 regs->PC = regs->CP0_EPC;
1930 /* I am not sure this is right, but it seems to work
1931 * maybe a problem with nested signals ? */
1932 regs->CP0_EPC = 0;
1933 return 0;
1934
1935 badframe:
1936 force_sig(TARGET_SIGSEGV/*, current*/);
1937 return 0;
1938
1939 }
1940
1941 static void setup_rt_frame(int sig, struct emulated_sigaction *ka,
1942 target_siginfo_t *info,
1943 target_sigset_t *set, CPUState *env)
1944 {
1945 fprintf(stderr, "setup_rt_frame: not implemented\n");
1946 }
1947
1948 long do_rt_sigreturn(CPUState *env)
1949 {
1950 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
1951 return -ENOSYS;
1952 }
1953
1954 #else
1955
1956 static void setup_frame(int sig, struct emulated_sigaction *ka,
1957 target_sigset_t *set, CPUState *env)
1958 {
1959 fprintf(stderr, "setup_frame: not implemented\n");
1960 }
1961
1962 static void setup_rt_frame(int sig, struct emulated_sigaction *ka,
1963 target_siginfo_t *info,
1964 target_sigset_t *set, CPUState *env)
1965 {
1966 fprintf(stderr, "setup_rt_frame: not implemented\n");
1967 }
1968
1969 long do_sigreturn(CPUState *env)
1970 {
1971 fprintf(stderr, "do_sigreturn: not implemented\n");
1972 return -ENOSYS;
1973 }
1974
1975 long do_rt_sigreturn(CPUState *env)
1976 {
1977 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
1978 return -ENOSYS;
1979 }
1980
1981 #endif
1982
1983 void process_pending_signals(void *cpu_env)
1984 {
1985 int sig;
1986 target_ulong handler;
1987 sigset_t set, old_set;
1988 target_sigset_t target_old_set;
1989 struct emulated_sigaction *k;
1990 struct sigqueue *q;
1991
1992 if (!signal_pending)
1993 return;
1994
1995 k = sigact_table;
1996 for(sig = 1; sig <= TARGET_NSIG; sig++) {
1997 if (k->pending)
1998 goto handle_signal;
1999 k++;
2000 }
2001 /* if no signal is pending, just return */
2002 signal_pending = 0;
2003 return;
2004
2005 handle_signal:
2006 #ifdef DEBUG_SIGNAL
2007 fprintf(stderr, "qemu: process signal %d\n", sig);
2008 #endif
2009 /* dequeue signal */
2010 q = k->first;
2011 k->first = q->next;
2012 if (!k->first)
2013 k->pending = 0;
2014
2015 sig = gdb_handlesig (cpu_env, sig);
2016 if (!sig) {
2017 fprintf (stderr, "Lost signal\n");
2018 abort();
2019 }
2020
2021 handler = k->sa._sa_handler;
2022 if (handler == TARGET_SIG_DFL) {
2023 /* default handler : ignore some signal. The other are fatal */
2024 if (sig != TARGET_SIGCHLD &&
2025 sig != TARGET_SIGURG &&
2026 sig != TARGET_SIGWINCH) {
2027 force_sig(sig);
2028 }
2029 } else if (handler == TARGET_SIG_IGN) {
2030 /* ignore sig */
2031 } else if (handler == TARGET_SIG_ERR) {
2032 force_sig(sig);
2033 } else {
2034 /* compute the blocked signals during the handler execution */
2035 target_to_host_sigset(&set, &k->sa.sa_mask);
2036 /* SA_NODEFER indicates that the current signal should not be
2037 blocked during the handler */
2038 if (!(k->sa.sa_flags & TARGET_SA_NODEFER))
2039 sigaddset(&set, target_to_host_signal(sig));
2040
2041 /* block signals in the handler using Linux */
2042 sigprocmask(SIG_BLOCK, &set, &old_set);
2043 /* save the previous blocked signal state to restore it at the
2044 end of the signal execution (see do_sigreturn) */
2045 host_to_target_sigset_internal(&target_old_set, &old_set);
2046
2047 /* if the CPU is in VM86 mode, we restore the 32 bit values */
2048 #ifdef TARGET_I386
2049 {
2050 CPUX86State *env = cpu_env;
2051 if (env->eflags & VM_MASK)
2052 save_v86_state(env);
2053 }
2054 #endif
2055 /* prepare the stack frame of the virtual CPU */
2056 if (k->sa.sa_flags & TARGET_SA_SIGINFO)
2057 setup_rt_frame(sig, k, &q->info, &target_old_set, cpu_env);
2058 else
2059 setup_frame(sig, k, &target_old_set, cpu_env);
2060 if (k->sa.sa_flags & TARGET_SA_RESETHAND)
2061 k->sa._sa_handler = TARGET_SIG_DFL;
2062 }
2063 if (q != &k->info)
2064 free_sigqueue(q);
2065 }
2066
2067
Samsung s3c2440 and arm920t support for the mini2440 dev board