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