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