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