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