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