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(¤t->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" (®s)); 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 2068