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