1 /* 2 * Emulation of Linux signals 3 * 4 * Copyright (c) 2003 Fabrice Bellard 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 19 * MA 02110-1301, USA. 20 */ 21 #include <stdlib.h> 22 #include <stdio.h> 23 #include <string.h> 24 #include <stdarg.h> 25 #include <unistd.h> 26 #include <signal.h> 27 #include <errno.h> 28 #include <assert.h> 29 #include <sys/ucontext.h> 30 #include <sys/resource.h> 31 32 #include "qemu.h" 33 #include "qemu-common.h" 34 #include "target_signal.h" 35 36 //#define DEBUG_SIGNAL 37 38 static struct target_sigaltstack target_sigaltstack_used = { 39 .ss_sp = 0, 40 .ss_size = 0, 41 .ss_flags = TARGET_SS_DISABLE, 42 }; 43 44 static struct target_sigaction sigact_table[TARGET_NSIG]; 45 46 static void host_signal_handler(int host_signum, siginfo_t *info, 47 void *puc); 48 49 static uint8_t host_to_target_signal_table[65] = { 50 [SIGHUP] = TARGET_SIGHUP, 51 [SIGINT] = TARGET_SIGINT, 52 [SIGQUIT] = TARGET_SIGQUIT, 53 [SIGILL] = TARGET_SIGILL, 54 [SIGTRAP] = TARGET_SIGTRAP, 55 [SIGABRT] = TARGET_SIGABRT, 56 /* [SIGIOT] = TARGET_SIGIOT,*/ 57 [SIGBUS] = TARGET_SIGBUS, 58 [SIGFPE] = TARGET_SIGFPE, 59 [SIGKILL] = TARGET_SIGKILL, 60 [SIGUSR1] = TARGET_SIGUSR1, 61 [SIGSEGV] = TARGET_SIGSEGV, 62 [SIGUSR2] = TARGET_SIGUSR2, 63 [SIGPIPE] = TARGET_SIGPIPE, 64 [SIGALRM] = TARGET_SIGALRM, 65 [SIGTERM] = TARGET_SIGTERM, 66 #ifdef SIGSTKFLT 67 [SIGSTKFLT] = TARGET_SIGSTKFLT, 68 #endif 69 [SIGCHLD] = TARGET_SIGCHLD, 70 [SIGCONT] = TARGET_SIGCONT, 71 [SIGSTOP] = TARGET_SIGSTOP, 72 [SIGTSTP] = TARGET_SIGTSTP, 73 [SIGTTIN] = TARGET_SIGTTIN, 74 [SIGTTOU] = TARGET_SIGTTOU, 75 [SIGURG] = TARGET_SIGURG, 76 [SIGXCPU] = TARGET_SIGXCPU, 77 [SIGXFSZ] = TARGET_SIGXFSZ, 78 [SIGVTALRM] = TARGET_SIGVTALRM, 79 [SIGPROF] = TARGET_SIGPROF, 80 [SIGWINCH] = TARGET_SIGWINCH, 81 [SIGIO] = TARGET_SIGIO, 82 [SIGPWR] = TARGET_SIGPWR, 83 [SIGSYS] = TARGET_SIGSYS, 84 /* next signals stay the same */ 85 /* Nasty hack: Reverse SIGRTMIN and SIGRTMAX to avoid overlap with 86 host libpthread signals. This assumes noone actually uses SIGRTMAX :-/ 87 To fix this properly we need to do manual signal delivery multiplexed 88 over a single host signal. */ 89 [__SIGRTMIN] = __SIGRTMAX, 90 [__SIGRTMAX] = __SIGRTMIN, 91 }; 92 static uint8_t target_to_host_signal_table[65]; 93 94 static inline int on_sig_stack(unsigned long sp) 95 { 96 return (sp - target_sigaltstack_used.ss_sp 97 < target_sigaltstack_used.ss_size); 98 } 99 100 static inline int sas_ss_flags(unsigned long sp) 101 { 102 return (target_sigaltstack_used.ss_size == 0 ? SS_DISABLE 103 : on_sig_stack(sp) ? SS_ONSTACK : 0); 104 } 105 106 int host_to_target_signal(int sig) 107 { 108 if (sig > 64) 109 return sig; 110 return host_to_target_signal_table[sig]; 111 } 112 113 int target_to_host_signal(int sig) 114 { 115 if (sig > 64) 116 return sig; 117 return target_to_host_signal_table[sig]; 118 } 119 120 static inline void target_sigemptyset(target_sigset_t *set) 121 { 122 memset(set, 0, sizeof(*set)); 123 } 124 125 static inline void target_sigaddset(target_sigset_t *set, int signum) 126 { 127 signum--; 128 abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW); 129 set->sig[signum / TARGET_NSIG_BPW] |= mask; 130 } 131 132 static inline int target_sigismember(const target_sigset_t *set, int signum) 133 { 134 signum--; 135 abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW); 136 return ((set->sig[signum / TARGET_NSIG_BPW] & mask) != 0); 137 } 138 139 static void host_to_target_sigset_internal(target_sigset_t *d, 140 const sigset_t *s) 141 { 142 int i; 143 target_sigemptyset(d); 144 for (i = 1; i <= TARGET_NSIG; i++) { 145 if (sigismember(s, i)) { 146 target_sigaddset(d, host_to_target_signal(i)); 147 } 148 } 149 } 150 151 void host_to_target_sigset(target_sigset_t *d, const sigset_t *s) 152 { 153 target_sigset_t d1; 154 int i; 155 156 host_to_target_sigset_internal(&d1, s); 157 for(i = 0;i < TARGET_NSIG_WORDS; i++) 158 d->sig[i] = tswapl(d1.sig[i]); 159 } 160 161 static void target_to_host_sigset_internal(sigset_t *d, 162 const target_sigset_t *s) 163 { 164 int i; 165 sigemptyset(d); 166 for (i = 1; i <= TARGET_NSIG; i++) { 167 if (target_sigismember(s, i)) { 168 sigaddset(d, target_to_host_signal(i)); 169 } 170 } 171 } 172 173 void target_to_host_sigset(sigset_t *d, const target_sigset_t *s) 174 { 175 target_sigset_t s1; 176 int i; 177 178 for(i = 0;i < TARGET_NSIG_WORDS; i++) 179 s1.sig[i] = tswapl(s->sig[i]); 180 target_to_host_sigset_internal(d, &s1); 181 } 182 183 void host_to_target_old_sigset(abi_ulong *old_sigset, 184 const sigset_t *sigset) 185 { 186 target_sigset_t d; 187 host_to_target_sigset(&d, sigset); 188 *old_sigset = d.sig[0]; 189 } 190 191 void target_to_host_old_sigset(sigset_t *sigset, 192 const abi_ulong *old_sigset) 193 { 194 target_sigset_t d; 195 int i; 196 197 d.sig[0] = *old_sigset; 198 for(i = 1;i < TARGET_NSIG_WORDS; i++) 199 d.sig[i] = 0; 200 target_to_host_sigset(sigset, &d); 201 } 202 203 /* siginfo conversion */ 204 205 static inline void host_to_target_siginfo_noswap(target_siginfo_t *tinfo, 206 const siginfo_t *info) 207 { 208 int sig; 209 sig = host_to_target_signal(info->si_signo); 210 tinfo->si_signo = sig; 211 tinfo->si_errno = 0; 212 tinfo->si_code = info->si_code; 213 if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV || 214 sig == SIGBUS || sig == SIGTRAP) { 215 /* should never come here, but who knows. The information for 216 the target is irrelevant */ 217 tinfo->_sifields._sigfault._addr = 0; 218 } else if (sig == SIGIO) { 219 tinfo->_sifields._sigpoll._fd = info->si_fd; 220 } else if (sig >= TARGET_SIGRTMIN) { 221 tinfo->_sifields._rt._pid = info->si_pid; 222 tinfo->_sifields._rt._uid = info->si_uid; 223 /* XXX: potential problem if 64 bit */ 224 tinfo->_sifields._rt._sigval.sival_ptr = 225 (abi_ulong)(unsigned long)info->si_value.sival_ptr; 226 } 227 } 228 229 static void tswap_siginfo(target_siginfo_t *tinfo, 230 const target_siginfo_t *info) 231 { 232 int sig; 233 sig = info->si_signo; 234 tinfo->si_signo = tswap32(sig); 235 tinfo->si_errno = tswap32(info->si_errno); 236 tinfo->si_code = tswap32(info->si_code); 237 if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV || 238 sig == SIGBUS || sig == SIGTRAP) { 239 tinfo->_sifields._sigfault._addr = 240 tswapl(info->_sifields._sigfault._addr); 241 } else if (sig == SIGIO) { 242 tinfo->_sifields._sigpoll._fd = tswap32(info->_sifields._sigpoll._fd); 243 } else if (sig >= TARGET_SIGRTMIN) { 244 tinfo->_sifields._rt._pid = tswap32(info->_sifields._rt._pid); 245 tinfo->_sifields._rt._uid = tswap32(info->_sifields._rt._uid); 246 tinfo->_sifields._rt._sigval.sival_ptr = 247 tswapl(info->_sifields._rt._sigval.sival_ptr); 248 } 249 } 250 251 252 void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info) 253 { 254 host_to_target_siginfo_noswap(tinfo, info); 255 tswap_siginfo(tinfo, tinfo); 256 } 257 258 /* XXX: we support only POSIX RT signals are used. */ 259 /* XXX: find a solution for 64 bit (additional malloced data is needed) */ 260 void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo) 261 { 262 info->si_signo = tswap32(tinfo->si_signo); 263 info->si_errno = tswap32(tinfo->si_errno); 264 info->si_code = tswap32(tinfo->si_code); 265 info->si_pid = tswap32(tinfo->_sifields._rt._pid); 266 info->si_uid = tswap32(tinfo->_sifields._rt._uid); 267 info->si_value.sival_ptr = 268 (void *)(long)tswapl(tinfo->_sifields._rt._sigval.sival_ptr); 269 } 270 271 static int fatal_signal (int sig) 272 { 273 switch (sig) { 274 case TARGET_SIGCHLD: 275 case TARGET_SIGURG: 276 case TARGET_SIGWINCH: 277 /* Ignored by default. */ 278 return 0; 279 case TARGET_SIGCONT: 280 case TARGET_SIGSTOP: 281 case TARGET_SIGTSTP: 282 case TARGET_SIGTTIN: 283 case TARGET_SIGTTOU: 284 /* Job control signals. */ 285 return 0; 286 default: 287 return 1; 288 } 289 } 290 291 /* returns 1 if given signal should dump core if not handled */ 292 static int core_dump_signal(int sig) 293 { 294 switch (sig) { 295 case TARGET_SIGABRT: 296 case TARGET_SIGFPE: 297 case TARGET_SIGILL: 298 case TARGET_SIGQUIT: 299 case TARGET_SIGSEGV: 300 case TARGET_SIGTRAP: 301 case TARGET_SIGBUS: 302 return (1); 303 default: 304 return (0); 305 } 306 } 307 308 void signal_init(void) 309 { 310 struct sigaction act; 311 struct sigaction oact; 312 int i, j; 313 int host_sig; 314 315 /* generate signal conversion tables */ 316 for(i = 1; i <= 64; i++) { 317 if (host_to_target_signal_table[i] == 0) 318 host_to_target_signal_table[i] = i; 319 } 320 for(i = 1; i <= 64; i++) { 321 j = host_to_target_signal_table[i]; 322 target_to_host_signal_table[j] = i; 323 } 324 325 /* set all host signal handlers. ALL signals are blocked during 326 the handlers to serialize them. */ 327 memset(sigact_table, 0, sizeof(sigact_table)); 328 329 sigfillset(&act.sa_mask); 330 act.sa_flags = SA_SIGINFO; 331 act.sa_sigaction = host_signal_handler; 332 for(i = 1; i <= TARGET_NSIG; i++) { 333 host_sig = target_to_host_signal(i); 334 sigaction(host_sig, NULL, &oact); 335 if (oact.sa_sigaction == (void *)SIG_IGN) { 336 sigact_table[i - 1]._sa_handler = TARGET_SIG_IGN; 337 } else if (oact.sa_sigaction == (void *)SIG_DFL) { 338 sigact_table[i - 1]._sa_handler = TARGET_SIG_DFL; 339 } 340 /* If there's already a handler installed then something has 341 gone horribly wrong, so don't even try to handle that case. */ 342 /* Install some handlers for our own use. We need at least 343 SIGSEGV and SIGBUS, to detect exceptions. We can not just 344 trap all signals because it affects syscall interrupt 345 behavior. But do trap all default-fatal signals. */ 346 if (fatal_signal (i)) 347 sigaction(host_sig, &act, NULL); 348 } 349 } 350 351 /* signal queue handling */ 352 353 static inline struct sigqueue *alloc_sigqueue(CPUState *env) 354 { 355 TaskState *ts = env->opaque; 356 struct sigqueue *q = ts->first_free; 357 if (!q) 358 return NULL; 359 ts->first_free = q->next; 360 return q; 361 } 362 363 static inline void free_sigqueue(CPUState *env, struct sigqueue *q) 364 { 365 TaskState *ts = env->opaque; 366 q->next = ts->first_free; 367 ts->first_free = q; 368 } 369 370 /* abort execution with signal */ 371 static void QEMU_NORETURN force_sig(int sig) 372 { 373 TaskState *ts = (TaskState *)thread_env->opaque; 374 int host_sig, core_dumped = 0; 375 struct sigaction act; 376 host_sig = target_to_host_signal(sig); 377 gdb_signalled(thread_env, sig); 378 379 /* dump core if supported by target binary format */ 380 if (core_dump_signal(sig) && (ts->bprm->core_dump != NULL)) { 381 stop_all_tasks(); 382 core_dumped = 383 ((*ts->bprm->core_dump)(sig, thread_env) == 0); 384 } 385 if (core_dumped) { 386 /* we already dumped the core of target process, we don't want 387 * a coredump of qemu itself */ 388 struct rlimit nodump; 389 getrlimit(RLIMIT_CORE, &nodump); 390 nodump.rlim_cur=0; 391 setrlimit(RLIMIT_CORE, &nodump); 392 (void) fprintf(stderr, "qemu: uncaught target signal %d (%s) - %s\n", 393 sig, strsignal(host_sig), "core dumped" ); 394 } 395 396 /* The proper exit code for dieing from an uncaught signal is 397 * -<signal>. The kernel doesn't allow exit() or _exit() to pass 398 * a negative value. To get the proper exit code we need to 399 * actually die from an uncaught signal. Here the default signal 400 * handler is installed, we send ourself a signal and we wait for 401 * it to arrive. */ 402 sigfillset(&act.sa_mask); 403 act.sa_handler = SIG_DFL; 404 sigaction(host_sig, &act, NULL); 405 406 /* For some reason raise(host_sig) doesn't send the signal when 407 * statically linked on x86-64. */ 408 kill(getpid(), host_sig); 409 410 /* Make sure the signal isn't masked (just reuse the mask inside 411 of act) */ 412 sigdelset(&act.sa_mask, host_sig); 413 sigsuspend(&act.sa_mask); 414 415 /* unreachable */ 416 assert(0); 417 418 } 419 420 /* queue a signal so that it will be send to the virtual CPU as soon 421 as possible */ 422 int queue_signal(CPUState *env, int sig, target_siginfo_t *info) 423 { 424 TaskState *ts = env->opaque; 425 struct emulated_sigtable *k; 426 struct sigqueue *q, **pq; 427 abi_ulong handler; 428 int queue; 429 430 #if defined(DEBUG_SIGNAL) 431 fprintf(stderr, "queue_signal: sig=%d\n", 432 sig); 433 #endif 434 k = &ts->sigtab[sig - 1]; 435 queue = gdb_queuesig (); 436 handler = sigact_table[sig - 1]._sa_handler; 437 if (!queue && handler == TARGET_SIG_DFL) { 438 if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) { 439 kill(getpid(),SIGSTOP); 440 return 0; 441 } else 442 /* default handler : ignore some signal. The other are fatal */ 443 if (sig != TARGET_SIGCHLD && 444 sig != TARGET_SIGURG && 445 sig != TARGET_SIGWINCH && 446 sig != TARGET_SIGCONT) { 447 force_sig(sig); 448 } else { 449 return 0; /* indicate ignored */ 450 } 451 } else if (!queue && handler == TARGET_SIG_IGN) { 452 /* ignore signal */ 453 return 0; 454 } else if (!queue && handler == TARGET_SIG_ERR) { 455 force_sig(sig); 456 } else { 457 pq = &k->first; 458 if (sig < TARGET_SIGRTMIN) { 459 /* if non real time signal, we queue exactly one signal */ 460 if (!k->pending) 461 q = &k->info; 462 else 463 return 0; 464 } else { 465 if (!k->pending) { 466 /* first signal */ 467 q = &k->info; 468 } else { 469 q = alloc_sigqueue(env); 470 if (!q) 471 return -EAGAIN; 472 while (*pq != NULL) 473 pq = &(*pq)->next; 474 } 475 } 476 *pq = q; 477 q->info = *info; 478 q->next = NULL; 479 k->pending = 1; 480 /* signal that a new signal is pending */ 481 ts->signal_pending = 1; 482 return 1; /* indicates that the signal was queued */ 483 } 484 } 485 486 static void host_signal_handler(int host_signum, siginfo_t *info, 487 void *puc) 488 { 489 int sig; 490 target_siginfo_t tinfo; 491 492 /* the CPU emulator uses some host signals to detect exceptions, 493 we forward to it some signals */ 494 if ((host_signum == SIGSEGV || host_signum == SIGBUS) 495 && info->si_code > 0) { 496 if (cpu_signal_handler(host_signum, info, puc)) 497 return; 498 } 499 500 /* get target signal number */ 501 sig = host_to_target_signal(host_signum); 502 if (sig < 1 || sig > TARGET_NSIG) 503 return; 504 #if defined(DEBUG_SIGNAL) 505 fprintf(stderr, "qemu: got signal %d\n", sig); 506 #endif 507 host_to_target_siginfo_noswap(&tinfo, info); 508 if (queue_signal(thread_env, sig, &tinfo) == 1) { 509 /* interrupt the virtual CPU as soon as possible */ 510 cpu_exit(thread_env); 511 } 512 } 513 514 /* do_sigaltstack() returns target values and errnos. */ 515 /* compare linux/kernel/signal.c:do_sigaltstack() */ 516 abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp) 517 { 518 int ret; 519 struct target_sigaltstack oss; 520 521 /* XXX: test errors */ 522 if(uoss_addr) 523 { 524 __put_user(target_sigaltstack_used.ss_sp, &oss.ss_sp); 525 __put_user(target_sigaltstack_used.ss_size, &oss.ss_size); 526 __put_user(sas_ss_flags(sp), &oss.ss_flags); 527 } 528 529 if(uss_addr) 530 { 531 struct target_sigaltstack *uss; 532 struct target_sigaltstack ss; 533 534 ret = -TARGET_EFAULT; 535 if (!lock_user_struct(VERIFY_READ, uss, uss_addr, 1) 536 || __get_user(ss.ss_sp, &uss->ss_sp) 537 || __get_user(ss.ss_size, &uss->ss_size) 538 || __get_user(ss.ss_flags, &uss->ss_flags)) 539 goto out; 540 unlock_user_struct(uss, uss_addr, 0); 541 542 ret = -TARGET_EPERM; 543 if (on_sig_stack(sp)) 544 goto out; 545 546 ret = -TARGET_EINVAL; 547 if (ss.ss_flags != TARGET_SS_DISABLE 548 && ss.ss_flags != TARGET_SS_ONSTACK 549 && ss.ss_flags != 0) 550 goto out; 551 552 if (ss.ss_flags == TARGET_SS_DISABLE) { 553 ss.ss_size = 0; 554 ss.ss_sp = 0; 555 } else { 556 ret = -TARGET_ENOMEM; 557 if (ss.ss_size < MINSIGSTKSZ) 558 goto out; 559 } 560 561 target_sigaltstack_used.ss_sp = ss.ss_sp; 562 target_sigaltstack_used.ss_size = ss.ss_size; 563 } 564 565 if (uoss_addr) { 566 ret = -TARGET_EFAULT; 567 if (copy_to_user(uoss_addr, &oss, sizeof(oss))) 568 goto out; 569 } 570 571 ret = 0; 572 out: 573 return ret; 574 } 575 576 /* do_sigaction() return host values and errnos */ 577 int do_sigaction(int sig, const struct target_sigaction *act, 578 struct target_sigaction *oact) 579 { 580 struct target_sigaction *k; 581 struct sigaction act1; 582 int host_sig; 583 int ret = 0; 584 585 if (sig < 1 || sig > TARGET_NSIG || sig == TARGET_SIGKILL || sig == TARGET_SIGSTOP) 586 return -EINVAL; 587 k = &sigact_table[sig - 1]; 588 #if defined(DEBUG_SIGNAL) 589 fprintf(stderr, "sigaction sig=%d act=0x%08x, oact=0x%08x\n", 590 sig, (int)act, (int)oact); 591 #endif 592 if (oact) { 593 oact->_sa_handler = tswapl(k->_sa_handler); 594 oact->sa_flags = tswapl(k->sa_flags); 595 #if !defined(TARGET_MIPS) 596 oact->sa_restorer = tswapl(k->sa_restorer); 597 #endif 598 oact->sa_mask = k->sa_mask; 599 } 600 if (act) { 601 /* FIXME: This is not threadsafe. */ 602 k->_sa_handler = tswapl(act->_sa_handler); 603 k->sa_flags = tswapl(act->sa_flags); 604 #if !defined(TARGET_MIPS) 605 k->sa_restorer = tswapl(act->sa_restorer); 606 #endif 607 k->sa_mask = act->sa_mask; 608 609 /* we update the host linux signal state */ 610 host_sig = target_to_host_signal(sig); 611 if (host_sig != SIGSEGV && host_sig != SIGBUS) { 612 sigfillset(&act1.sa_mask); 613 act1.sa_flags = SA_SIGINFO; 614 if (k->sa_flags & TARGET_SA_RESTART) 615 act1.sa_flags |= SA_RESTART; 616 /* NOTE: it is important to update the host kernel signal 617 ignore state to avoid getting unexpected interrupted 618 syscalls */ 619 if (k->_sa_handler == TARGET_SIG_IGN) { 620 act1.sa_sigaction = (void *)SIG_IGN; 621 } else if (k->_sa_handler == TARGET_SIG_DFL) { 622 if (fatal_signal (sig)) 623 act1.sa_sigaction = host_signal_handler; 624 else 625 act1.sa_sigaction = (void *)SIG_DFL; 626 } else { 627 act1.sa_sigaction = host_signal_handler; 628 } 629 ret = sigaction(host_sig, &act1, NULL); 630 } 631 } 632 return ret; 633 } 634 635 static inline int copy_siginfo_to_user(target_siginfo_t *tinfo, 636 const target_siginfo_t *info) 637 { 638 tswap_siginfo(tinfo, info); 639 return 0; 640 } 641 642 static inline int current_exec_domain_sig(int sig) 643 { 644 return /* current->exec_domain && current->exec_domain->signal_invmap 645 && sig < 32 ? current->exec_domain->signal_invmap[sig] : */ sig; 646 } 647 648 #if defined(TARGET_I386) && TARGET_ABI_BITS == 32 649 650 /* from the Linux kernel */ 651 652 struct target_fpreg { 653 uint16_t significand[4]; 654 uint16_t exponent; 655 }; 656 657 struct target_fpxreg { 658 uint16_t significand[4]; 659 uint16_t exponent; 660 uint16_t padding[3]; 661 }; 662 663 struct target_xmmreg { 664 abi_ulong element[4]; 665 }; 666 667 struct target_fpstate { 668 /* Regular FPU environment */ 669 abi_ulong cw; 670 abi_ulong sw; 671 abi_ulong tag; 672 abi_ulong ipoff; 673 abi_ulong cssel; 674 abi_ulong dataoff; 675 abi_ulong datasel; 676 struct target_fpreg _st[8]; 677 uint16_t status; 678 uint16_t magic; /* 0xffff = regular FPU data only */ 679 680 /* FXSR FPU environment */ 681 abi_ulong _fxsr_env[6]; /* FXSR FPU env is ignored */ 682 abi_ulong mxcsr; 683 abi_ulong reserved; 684 struct target_fpxreg _fxsr_st[8]; /* FXSR FPU reg data is ignored */ 685 struct target_xmmreg _xmm[8]; 686 abi_ulong padding[56]; 687 }; 688 689 #define X86_FXSR_MAGIC 0x0000 690 691 struct target_sigcontext { 692 uint16_t gs, __gsh; 693 uint16_t fs, __fsh; 694 uint16_t es, __esh; 695 uint16_t ds, __dsh; 696 abi_ulong edi; 697 abi_ulong esi; 698 abi_ulong ebp; 699 abi_ulong esp; 700 abi_ulong ebx; 701 abi_ulong edx; 702 abi_ulong ecx; 703 abi_ulong eax; 704 abi_ulong trapno; 705 abi_ulong err; 706 abi_ulong eip; 707 uint16_t cs, __csh; 708 abi_ulong eflags; 709 abi_ulong esp_at_signal; 710 uint16_t ss, __ssh; 711 abi_ulong fpstate; /* pointer */ 712 abi_ulong oldmask; 713 abi_ulong cr2; 714 }; 715 716 struct target_ucontext { 717 abi_ulong tuc_flags; 718 abi_ulong tuc_link; 719 target_stack_t tuc_stack; 720 struct target_sigcontext tuc_mcontext; 721 target_sigset_t tuc_sigmask; /* mask last for extensibility */ 722 }; 723 724 struct sigframe 725 { 726 abi_ulong pretcode; 727 int sig; 728 struct target_sigcontext sc; 729 struct target_fpstate fpstate; 730 abi_ulong extramask[TARGET_NSIG_WORDS-1]; 731 char retcode[8]; 732 }; 733 734 struct rt_sigframe 735 { 736 abi_ulong pretcode; 737 int sig; 738 abi_ulong pinfo; 739 abi_ulong puc; 740 struct target_siginfo info; 741 struct target_ucontext uc; 742 struct target_fpstate fpstate; 743 char retcode[8]; 744 }; 745 746 /* 747 * Set up a signal frame. 748 */ 749 750 /* XXX: save x87 state */ 751 static int 752 setup_sigcontext(struct target_sigcontext *sc, struct target_fpstate *fpstate, 753 CPUX86State *env, abi_ulong mask, abi_ulong fpstate_addr) 754 { 755 int err = 0; 756 uint16_t magic; 757 758 /* already locked in setup_frame() */ 759 err |= __put_user(env->segs[R_GS].selector, (unsigned int *)&sc->gs); 760 err |= __put_user(env->segs[R_FS].selector, (unsigned int *)&sc->fs); 761 err |= __put_user(env->segs[R_ES].selector, (unsigned int *)&sc->es); 762 err |= __put_user(env->segs[R_DS].selector, (unsigned int *)&sc->ds); 763 err |= __put_user(env->regs[R_EDI], &sc->edi); 764 err |= __put_user(env->regs[R_ESI], &sc->esi); 765 err |= __put_user(env->regs[R_EBP], &sc->ebp); 766 err |= __put_user(env->regs[R_ESP], &sc->esp); 767 err |= __put_user(env->regs[R_EBX], &sc->ebx); 768 err |= __put_user(env->regs[R_EDX], &sc->edx); 769 err |= __put_user(env->regs[R_ECX], &sc->ecx); 770 err |= __put_user(env->regs[R_EAX], &sc->eax); 771 err |= __put_user(env->exception_index, &sc->trapno); 772 err |= __put_user(env->error_code, &sc->err); 773 err |= __put_user(env->eip, &sc->eip); 774 err |= __put_user(env->segs[R_CS].selector, (unsigned int *)&sc->cs); 775 err |= __put_user(env->eflags, &sc->eflags); 776 err |= __put_user(env->regs[R_ESP], &sc->esp_at_signal); 777 err |= __put_user(env->segs[R_SS].selector, (unsigned int *)&sc->ss); 778 779 cpu_x86_fsave(env, fpstate_addr, 1); 780 fpstate->status = fpstate->sw; 781 magic = 0xffff; 782 err |= __put_user(magic, &fpstate->magic); 783 err |= __put_user(fpstate_addr, &sc->fpstate); 784 785 /* non-iBCS2 extensions.. */ 786 err |= __put_user(mask, &sc->oldmask); 787 err |= __put_user(env->cr[2], &sc->cr2); 788 return err; 789 } 790 791 /* 792 * Determine which stack to use.. 793 */ 794 795 static inline abi_ulong 796 get_sigframe(struct target_sigaction *ka, CPUX86State *env, size_t frame_size) 797 { 798 unsigned long esp; 799 800 /* Default to using normal stack */ 801 esp = env->regs[R_ESP]; 802 /* This is the X/Open sanctioned signal stack switching. */ 803 if (ka->sa_flags & TARGET_SA_ONSTACK) { 804 if (sas_ss_flags(esp) == 0) 805 esp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 806 } 807 808 /* This is the legacy signal stack switching. */ 809 else 810 if ((env->segs[R_SS].selector & 0xffff) != __USER_DS && 811 !(ka->sa_flags & TARGET_SA_RESTORER) && 812 ka->sa_restorer) { 813 esp = (unsigned long) ka->sa_restorer; 814 } 815 return (esp - frame_size) & -8ul; 816 } 817 818 /* compare linux/arch/i386/kernel/signal.c:setup_frame() */ 819 static void setup_frame(int sig, struct target_sigaction *ka, 820 target_sigset_t *set, CPUX86State *env) 821 { 822 abi_ulong frame_addr; 823 struct sigframe *frame; 824 int i, err = 0; 825 826 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 827 828 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 829 goto give_sigsegv; 830 831 err |= __put_user(current_exec_domain_sig(sig), 832 &frame->sig); 833 if (err) 834 goto give_sigsegv; 835 836 setup_sigcontext(&frame->sc, &frame->fpstate, env, set->sig[0], 837 frame_addr + offsetof(struct sigframe, fpstate)); 838 if (err) 839 goto give_sigsegv; 840 841 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 842 if (__put_user(set->sig[i], &frame->extramask[i - 1])) 843 goto give_sigsegv; 844 } 845 846 /* Set up to return from userspace. If provided, use a stub 847 already in userspace. */ 848 if (ka->sa_flags & TARGET_SA_RESTORER) { 849 err |= __put_user(ka->sa_restorer, &frame->pretcode); 850 } else { 851 uint16_t val16; 852 abi_ulong retcode_addr; 853 retcode_addr = frame_addr + offsetof(struct sigframe, retcode); 854 err |= __put_user(retcode_addr, &frame->pretcode); 855 /* This is popl %eax ; movl $,%eax ; int $0x80 */ 856 val16 = 0xb858; 857 err |= __put_user(val16, (uint16_t *)(frame->retcode+0)); 858 err |= __put_user(TARGET_NR_sigreturn, (int *)(frame->retcode+2)); 859 val16 = 0x80cd; 860 err |= __put_user(val16, (uint16_t *)(frame->retcode+6)); 861 } 862 863 if (err) 864 goto give_sigsegv; 865 866 /* Set up registers for signal handler */ 867 env->regs[R_ESP] = frame_addr; 868 env->eip = ka->_sa_handler; 869 870 cpu_x86_load_seg(env, R_DS, __USER_DS); 871 cpu_x86_load_seg(env, R_ES, __USER_DS); 872 cpu_x86_load_seg(env, R_SS, __USER_DS); 873 cpu_x86_load_seg(env, R_CS, __USER_CS); 874 env->eflags &= ~TF_MASK; 875 876 unlock_user_struct(frame, frame_addr, 1); 877 878 return; 879 880 give_sigsegv: 881 unlock_user_struct(frame, frame_addr, 1); 882 if (sig == TARGET_SIGSEGV) 883 ka->_sa_handler = TARGET_SIG_DFL; 884 force_sig(TARGET_SIGSEGV /* , current */); 885 } 886 887 /* compare linux/arch/i386/kernel/signal.c:setup_rt_frame() */ 888 static void setup_rt_frame(int sig, struct target_sigaction *ka, 889 target_siginfo_t *info, 890 target_sigset_t *set, CPUX86State *env) 891 { 892 abi_ulong frame_addr, addr; 893 struct rt_sigframe *frame; 894 int i, err = 0; 895 896 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 897 898 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 899 goto give_sigsegv; 900 901 err |= __put_user(current_exec_domain_sig(sig), 902 &frame->sig); 903 addr = frame_addr + offsetof(struct rt_sigframe, info); 904 err |= __put_user(addr, &frame->pinfo); 905 addr = frame_addr + offsetof(struct rt_sigframe, uc); 906 err |= __put_user(addr, &frame->puc); 907 err |= copy_siginfo_to_user(&frame->info, info); 908 if (err) 909 goto give_sigsegv; 910 911 /* Create the ucontext. */ 912 err |= __put_user(0, &frame->uc.tuc_flags); 913 err |= __put_user(0, &frame->uc.tuc_link); 914 err |= __put_user(target_sigaltstack_used.ss_sp, 915 &frame->uc.tuc_stack.ss_sp); 916 err |= __put_user(sas_ss_flags(get_sp_from_cpustate(env)), 917 &frame->uc.tuc_stack.ss_flags); 918 err |= __put_user(target_sigaltstack_used.ss_size, 919 &frame->uc.tuc_stack.ss_size); 920 err |= setup_sigcontext(&frame->uc.tuc_mcontext, &frame->fpstate, 921 env, set->sig[0], 922 frame_addr + offsetof(struct rt_sigframe, fpstate)); 923 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 924 if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i])) 925 goto give_sigsegv; 926 } 927 928 /* Set up to return from userspace. If provided, use a stub 929 already in userspace. */ 930 if (ka->sa_flags & TARGET_SA_RESTORER) { 931 err |= __put_user(ka->sa_restorer, &frame->pretcode); 932 } else { 933 uint16_t val16; 934 addr = frame_addr + offsetof(struct rt_sigframe, retcode); 935 err |= __put_user(addr, &frame->pretcode); 936 /* This is movl $,%eax ; int $0x80 */ 937 err |= __put_user(0xb8, (char *)(frame->retcode+0)); 938 err |= __put_user(TARGET_NR_rt_sigreturn, (int *)(frame->retcode+1)); 939 val16 = 0x80cd; 940 err |= __put_user(val16, (uint16_t *)(frame->retcode+5)); 941 } 942 943 if (err) 944 goto give_sigsegv; 945 946 /* Set up registers for signal handler */ 947 env->regs[R_ESP] = frame_addr; 948 env->eip = ka->_sa_handler; 949 950 cpu_x86_load_seg(env, R_DS, __USER_DS); 951 cpu_x86_load_seg(env, R_ES, __USER_DS); 952 cpu_x86_load_seg(env, R_SS, __USER_DS); 953 cpu_x86_load_seg(env, R_CS, __USER_CS); 954 env->eflags &= ~TF_MASK; 955 956 unlock_user_struct(frame, frame_addr, 1); 957 958 return; 959 960 give_sigsegv: 961 unlock_user_struct(frame, frame_addr, 1); 962 if (sig == TARGET_SIGSEGV) 963 ka->_sa_handler = TARGET_SIG_DFL; 964 force_sig(TARGET_SIGSEGV /* , current */); 965 } 966 967 static int 968 restore_sigcontext(CPUX86State *env, struct target_sigcontext *sc, int *peax) 969 { 970 unsigned int err = 0; 971 abi_ulong fpstate_addr; 972 unsigned int tmpflags; 973 974 cpu_x86_load_seg(env, R_GS, tswap16(sc->gs)); 975 cpu_x86_load_seg(env, R_FS, tswap16(sc->fs)); 976 cpu_x86_load_seg(env, R_ES, tswap16(sc->es)); 977 cpu_x86_load_seg(env, R_DS, tswap16(sc->ds)); 978 979 env->regs[R_EDI] = tswapl(sc->edi); 980 env->regs[R_ESI] = tswapl(sc->esi); 981 env->regs[R_EBP] = tswapl(sc->ebp); 982 env->regs[R_ESP] = tswapl(sc->esp); 983 env->regs[R_EBX] = tswapl(sc->ebx); 984 env->regs[R_EDX] = tswapl(sc->edx); 985 env->regs[R_ECX] = tswapl(sc->ecx); 986 env->eip = tswapl(sc->eip); 987 988 cpu_x86_load_seg(env, R_CS, lduw(&sc->cs) | 3); 989 cpu_x86_load_seg(env, R_SS, lduw(&sc->ss) | 3); 990 991 tmpflags = tswapl(sc->eflags); 992 env->eflags = (env->eflags & ~0x40DD5) | (tmpflags & 0x40DD5); 993 // regs->orig_eax = -1; /* disable syscall checks */ 994 995 fpstate_addr = tswapl(sc->fpstate); 996 if (fpstate_addr != 0) { 997 if (!access_ok(VERIFY_READ, fpstate_addr, 998 sizeof(struct target_fpstate))) 999 goto badframe; 1000 cpu_x86_frstor(env, fpstate_addr, 1); 1001 } 1002 1003 *peax = tswapl(sc->eax); 1004 return err; 1005 badframe: 1006 return 1; 1007 } 1008 1009 long do_sigreturn(CPUX86State *env) 1010 { 1011 struct sigframe *frame; 1012 abi_ulong frame_addr = env->regs[R_ESP] - 8; 1013 target_sigset_t target_set; 1014 sigset_t set; 1015 int eax, i; 1016 1017 #if defined(DEBUG_SIGNAL) 1018 fprintf(stderr, "do_sigreturn\n"); 1019 #endif 1020 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 1021 goto badframe; 1022 /* set blocked signals */ 1023 if (__get_user(target_set.sig[0], &frame->sc.oldmask)) 1024 goto badframe; 1025 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 1026 if (__get_user(target_set.sig[i], &frame->extramask[i - 1])) 1027 goto badframe; 1028 } 1029 1030 target_to_host_sigset_internal(&set, &target_set); 1031 sigprocmask(SIG_SETMASK, &set, NULL); 1032 1033 /* restore registers */ 1034 if (restore_sigcontext(env, &frame->sc, &eax)) 1035 goto badframe; 1036 unlock_user_struct(frame, frame_addr, 0); 1037 return eax; 1038 1039 badframe: 1040 unlock_user_struct(frame, frame_addr, 0); 1041 force_sig(TARGET_SIGSEGV); 1042 return 0; 1043 } 1044 1045 long do_rt_sigreturn(CPUX86State *env) 1046 { 1047 abi_ulong frame_addr; 1048 struct rt_sigframe *frame; 1049 sigset_t set; 1050 int eax; 1051 1052 frame_addr = env->regs[R_ESP] - 4; 1053 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 1054 goto badframe; 1055 target_to_host_sigset(&set, &frame->uc.tuc_sigmask); 1056 sigprocmask(SIG_SETMASK, &set, NULL); 1057 1058 if (restore_sigcontext(env, &frame->uc.tuc_mcontext, &eax)) 1059 goto badframe; 1060 1061 if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe, uc.tuc_stack), 0, 1062 get_sp_from_cpustate(env)) == -EFAULT) 1063 goto badframe; 1064 1065 unlock_user_struct(frame, frame_addr, 0); 1066 return eax; 1067 1068 badframe: 1069 unlock_user_struct(frame, frame_addr, 0); 1070 force_sig(TARGET_SIGSEGV); 1071 return 0; 1072 } 1073 1074 #elif defined(TARGET_ARM) 1075 1076 struct target_sigcontext { 1077 abi_ulong trap_no; 1078 abi_ulong error_code; 1079 abi_ulong oldmask; 1080 abi_ulong arm_r0; 1081 abi_ulong arm_r1; 1082 abi_ulong arm_r2; 1083 abi_ulong arm_r3; 1084 abi_ulong arm_r4; 1085 abi_ulong arm_r5; 1086 abi_ulong arm_r6; 1087 abi_ulong arm_r7; 1088 abi_ulong arm_r8; 1089 abi_ulong arm_r9; 1090 abi_ulong arm_r10; 1091 abi_ulong arm_fp; 1092 abi_ulong arm_ip; 1093 abi_ulong arm_sp; 1094 abi_ulong arm_lr; 1095 abi_ulong arm_pc; 1096 abi_ulong arm_cpsr; 1097 abi_ulong fault_address; 1098 }; 1099 1100 struct target_ucontext_v1 { 1101 abi_ulong tuc_flags; 1102 abi_ulong tuc_link; 1103 target_stack_t tuc_stack; 1104 struct target_sigcontext tuc_mcontext; 1105 target_sigset_t tuc_sigmask; /* mask last for extensibility */ 1106 }; 1107 1108 struct target_ucontext_v2 { 1109 abi_ulong tuc_flags; 1110 abi_ulong tuc_link; 1111 target_stack_t tuc_stack; 1112 struct target_sigcontext tuc_mcontext; 1113 target_sigset_t tuc_sigmask; /* mask last for extensibility */ 1114 char __unused[128 - sizeof(sigset_t)]; 1115 abi_ulong tuc_regspace[128] __attribute__((__aligned__(8))); 1116 }; 1117 1118 struct sigframe_v1 1119 { 1120 struct target_sigcontext sc; 1121 abi_ulong extramask[TARGET_NSIG_WORDS-1]; 1122 abi_ulong retcode; 1123 }; 1124 1125 struct sigframe_v2 1126 { 1127 struct target_ucontext_v2 uc; 1128 abi_ulong retcode; 1129 }; 1130 1131 struct rt_sigframe_v1 1132 { 1133 abi_ulong pinfo; 1134 abi_ulong puc; 1135 struct target_siginfo info; 1136 struct target_ucontext_v1 uc; 1137 abi_ulong retcode; 1138 }; 1139 1140 struct rt_sigframe_v2 1141 { 1142 struct target_siginfo info; 1143 struct target_ucontext_v2 uc; 1144 abi_ulong retcode; 1145 }; 1146 1147 #define TARGET_CONFIG_CPU_32 1 1148 1149 /* 1150 * For ARM syscalls, we encode the syscall number into the instruction. 1151 */ 1152 #define SWI_SYS_SIGRETURN (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE)) 1153 #define SWI_SYS_RT_SIGRETURN (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE)) 1154 1155 /* 1156 * For Thumb syscalls, we pass the syscall number via r7. We therefore 1157 * need two 16-bit instructions. 1158 */ 1159 #define SWI_THUMB_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn)) 1160 #define SWI_THUMB_RT_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn)) 1161 1162 static const abi_ulong retcodes[4] = { 1163 SWI_SYS_SIGRETURN, SWI_THUMB_SIGRETURN, 1164 SWI_SYS_RT_SIGRETURN, SWI_THUMB_RT_SIGRETURN 1165 }; 1166 1167 1168 #define __get_user_error(x,p,e) __get_user(x, p) 1169 1170 static inline int valid_user_regs(CPUState *regs) 1171 { 1172 return 1; 1173 } 1174 1175 static void 1176 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/ 1177 CPUState *env, abi_ulong mask) 1178 { 1179 __put_user(env->regs[0], &sc->arm_r0); 1180 __put_user(env->regs[1], &sc->arm_r1); 1181 __put_user(env->regs[2], &sc->arm_r2); 1182 __put_user(env->regs[3], &sc->arm_r3); 1183 __put_user(env->regs[4], &sc->arm_r4); 1184 __put_user(env->regs[5], &sc->arm_r5); 1185 __put_user(env->regs[6], &sc->arm_r6); 1186 __put_user(env->regs[7], &sc->arm_r7); 1187 __put_user(env->regs[8], &sc->arm_r8); 1188 __put_user(env->regs[9], &sc->arm_r9); 1189 __put_user(env->regs[10], &sc->arm_r10); 1190 __put_user(env->regs[11], &sc->arm_fp); 1191 __put_user(env->regs[12], &sc->arm_ip); 1192 __put_user(env->regs[13], &sc->arm_sp); 1193 __put_user(env->regs[14], &sc->arm_lr); 1194 __put_user(env->regs[15], &sc->arm_pc); 1195 #ifdef TARGET_CONFIG_CPU_32 1196 __put_user(cpsr_read(env), &sc->arm_cpsr); 1197 #endif 1198 1199 __put_user(/* current->thread.trap_no */ 0, &sc->trap_no); 1200 __put_user(/* current->thread.error_code */ 0, &sc->error_code); 1201 __put_user(/* current->thread.address */ 0, &sc->fault_address); 1202 __put_user(mask, &sc->oldmask); 1203 } 1204 1205 static inline abi_ulong 1206 get_sigframe(struct target_sigaction *ka, CPUState *regs, int framesize) 1207 { 1208 unsigned long sp = regs->regs[13]; 1209 1210 /* 1211 * This is the X/Open sanctioned signal stack switching. 1212 */ 1213 if ((ka->sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp)) 1214 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 1215 /* 1216 * ATPCS B01 mandates 8-byte alignment 1217 */ 1218 return (sp - framesize) & ~7; 1219 } 1220 1221 static int 1222 setup_return(CPUState *env, struct target_sigaction *ka, 1223 abi_ulong *rc, abi_ulong frame_addr, int usig, abi_ulong rc_addr) 1224 { 1225 abi_ulong handler = ka->_sa_handler; 1226 abi_ulong retcode; 1227 int thumb = handler & 1; 1228 1229 if (ka->sa_flags & TARGET_SA_RESTORER) { 1230 retcode = ka->sa_restorer; 1231 } else { 1232 unsigned int idx = thumb; 1233 1234 if (ka->sa_flags & TARGET_SA_SIGINFO) 1235 idx += 2; 1236 1237 if (__put_user(retcodes[idx], rc)) 1238 return 1; 1239 #if 0 1240 flush_icache_range((abi_ulong)rc, 1241 (abi_ulong)(rc + 1)); 1242 #endif 1243 retcode = rc_addr + thumb; 1244 } 1245 1246 env->regs[0] = usig; 1247 env->regs[13] = frame_addr; 1248 env->regs[14] = retcode; 1249 env->regs[15] = handler & (thumb ? ~1 : ~3); 1250 env->thumb = thumb; 1251 1252 #if 0 1253 #ifdef TARGET_CONFIG_CPU_32 1254 env->cpsr = cpsr; 1255 #endif 1256 #endif 1257 1258 return 0; 1259 } 1260 1261 static void setup_sigframe_v2(struct target_ucontext_v2 *uc, 1262 target_sigset_t *set, CPUState *env) 1263 { 1264 struct target_sigaltstack stack; 1265 int i; 1266 1267 /* Clear all the bits of the ucontext we don't use. */ 1268 memset(uc, 0, offsetof(struct target_ucontext_v2, tuc_mcontext)); 1269 1270 memset(&stack, 0, sizeof(stack)); 1271 __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp); 1272 __put_user(target_sigaltstack_used.ss_size, &stack.ss_size); 1273 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags); 1274 memcpy(&uc->tuc_stack, &stack, sizeof(stack)); 1275 1276 setup_sigcontext(&uc->tuc_mcontext, env, set->sig[0]); 1277 /* FIXME: Save coprocessor signal frame. */ 1278 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 1279 __put_user(set->sig[i], &uc->tuc_sigmask.sig[i]); 1280 } 1281 } 1282 1283 /* compare linux/arch/arm/kernel/signal.c:setup_frame() */ 1284 static void setup_frame_v1(int usig, struct target_sigaction *ka, 1285 target_sigset_t *set, CPUState *regs) 1286 { 1287 struct sigframe_v1 *frame; 1288 abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame)); 1289 int i; 1290 1291 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 1292 return; 1293 1294 setup_sigcontext(&frame->sc, regs, set->sig[0]); 1295 1296 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 1297 if (__put_user(set->sig[i], &frame->extramask[i - 1])) 1298 goto end; 1299 } 1300 1301 setup_return(regs, ka, &frame->retcode, frame_addr, usig, 1302 frame_addr + offsetof(struct sigframe_v1, retcode)); 1303 1304 end: 1305 unlock_user_struct(frame, frame_addr, 1); 1306 } 1307 1308 static void setup_frame_v2(int usig, struct target_sigaction *ka, 1309 target_sigset_t *set, CPUState *regs) 1310 { 1311 struct sigframe_v2 *frame; 1312 abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame)); 1313 1314 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 1315 return; 1316 1317 setup_sigframe_v2(&frame->uc, set, regs); 1318 1319 setup_return(regs, ka, &frame->retcode, frame_addr, usig, 1320 frame_addr + offsetof(struct sigframe_v2, retcode)); 1321 1322 unlock_user_struct(frame, frame_addr, 1); 1323 } 1324 1325 static void setup_frame(int usig, struct target_sigaction *ka, 1326 target_sigset_t *set, CPUState *regs) 1327 { 1328 if (get_osversion() >= 0x020612) { 1329 setup_frame_v2(usig, ka, set, regs); 1330 } else { 1331 setup_frame_v1(usig, ka, set, regs); 1332 } 1333 } 1334 1335 /* compare linux/arch/arm/kernel/signal.c:setup_rt_frame() */ 1336 static void setup_rt_frame_v1(int usig, struct target_sigaction *ka, 1337 target_siginfo_t *info, 1338 target_sigset_t *set, CPUState *env) 1339 { 1340 struct rt_sigframe_v1 *frame; 1341 abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame)); 1342 struct target_sigaltstack stack; 1343 int i; 1344 abi_ulong info_addr, uc_addr; 1345 1346 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 1347 return /* 1 */; 1348 1349 info_addr = frame_addr + offsetof(struct rt_sigframe_v1, info); 1350 __put_user(info_addr, &frame->pinfo); 1351 uc_addr = frame_addr + offsetof(struct rt_sigframe_v1, uc); 1352 __put_user(uc_addr, &frame->puc); 1353 copy_siginfo_to_user(&frame->info, info); 1354 1355 /* Clear all the bits of the ucontext we don't use. */ 1356 memset(&frame->uc, 0, offsetof(struct target_ucontext_v1, tuc_mcontext)); 1357 1358 memset(&stack, 0, sizeof(stack)); 1359 __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp); 1360 __put_user(target_sigaltstack_used.ss_size, &stack.ss_size); 1361 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags); 1362 memcpy(&frame->uc.tuc_stack, &stack, sizeof(stack)); 1363 1364 setup_sigcontext(&frame->uc.tuc_mcontext, env, set->sig[0]); 1365 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 1366 if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i])) 1367 goto end; 1368 } 1369 1370 setup_return(env, ka, &frame->retcode, frame_addr, usig, 1371 frame_addr + offsetof(struct rt_sigframe_v1, retcode)); 1372 1373 env->regs[1] = info_addr; 1374 env->regs[2] = uc_addr; 1375 1376 end: 1377 unlock_user_struct(frame, frame_addr, 1); 1378 } 1379 1380 static void setup_rt_frame_v2(int usig, struct target_sigaction *ka, 1381 target_siginfo_t *info, 1382 target_sigset_t *set, CPUState *env) 1383 { 1384 struct rt_sigframe_v2 *frame; 1385 abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame)); 1386 abi_ulong info_addr, uc_addr; 1387 1388 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 1389 return /* 1 */; 1390 1391 info_addr = frame_addr + offsetof(struct rt_sigframe_v2, info); 1392 uc_addr = frame_addr + offsetof(struct rt_sigframe_v2, uc); 1393 copy_siginfo_to_user(&frame->info, info); 1394 1395 setup_sigframe_v2(&frame->uc, set, env); 1396 1397 setup_return(env, ka, &frame->retcode, frame_addr, usig, 1398 frame_addr + offsetof(struct rt_sigframe_v2, retcode)); 1399 1400 env->regs[1] = info_addr; 1401 env->regs[2] = uc_addr; 1402 1403 unlock_user_struct(frame, frame_addr, 1); 1404 } 1405 1406 static void setup_rt_frame(int usig, struct target_sigaction *ka, 1407 target_siginfo_t *info, 1408 target_sigset_t *set, CPUState *env) 1409 { 1410 if (get_osversion() >= 0x020612) { 1411 setup_rt_frame_v2(usig, ka, info, set, env); 1412 } else { 1413 setup_rt_frame_v1(usig, ka, info, set, env); 1414 } 1415 } 1416 1417 static int 1418 restore_sigcontext(CPUState *env, struct target_sigcontext *sc) 1419 { 1420 int err = 0; 1421 uint32_t cpsr; 1422 1423 __get_user_error(env->regs[0], &sc->arm_r0, err); 1424 __get_user_error(env->regs[1], &sc->arm_r1, err); 1425 __get_user_error(env->regs[2], &sc->arm_r2, err); 1426 __get_user_error(env->regs[3], &sc->arm_r3, err); 1427 __get_user_error(env->regs[4], &sc->arm_r4, err); 1428 __get_user_error(env->regs[5], &sc->arm_r5, err); 1429 __get_user_error(env->regs[6], &sc->arm_r6, err); 1430 __get_user_error(env->regs[7], &sc->arm_r7, err); 1431 __get_user_error(env->regs[8], &sc->arm_r8, err); 1432 __get_user_error(env->regs[9], &sc->arm_r9, err); 1433 __get_user_error(env->regs[10], &sc->arm_r10, err); 1434 __get_user_error(env->regs[11], &sc->arm_fp, err); 1435 __get_user_error(env->regs[12], &sc->arm_ip, err); 1436 __get_user_error(env->regs[13], &sc->arm_sp, err); 1437 __get_user_error(env->regs[14], &sc->arm_lr, err); 1438 __get_user_error(env->regs[15], &sc->arm_pc, err); 1439 #ifdef TARGET_CONFIG_CPU_32 1440 __get_user_error(cpsr, &sc->arm_cpsr, err); 1441 cpsr_write(env, cpsr, CPSR_USER | CPSR_EXEC); 1442 #endif 1443 1444 err |= !valid_user_regs(env); 1445 1446 return err; 1447 } 1448 1449 static long do_sigreturn_v1(CPUState *env) 1450 { 1451 abi_ulong frame_addr; 1452 struct sigframe_v1 *frame; 1453 target_sigset_t set; 1454 sigset_t host_set; 1455 int i; 1456 1457 /* 1458 * Since we stacked the signal on a 64-bit boundary, 1459 * then 'sp' should be word aligned here. If it's 1460 * not, then the user is trying to mess with us. 1461 */ 1462 if (env->regs[13] & 7) 1463 goto badframe; 1464 1465 frame_addr = env->regs[13]; 1466 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 1467 goto badframe; 1468 1469 if (__get_user(set.sig[0], &frame->sc.oldmask)) 1470 goto badframe; 1471 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 1472 if (__get_user(set.sig[i], &frame->extramask[i - 1])) 1473 goto badframe; 1474 } 1475 1476 target_to_host_sigset_internal(&host_set, &set); 1477 sigprocmask(SIG_SETMASK, &host_set, NULL); 1478 1479 if (restore_sigcontext(env, &frame->sc)) 1480 goto badframe; 1481 1482 #if 0 1483 /* Send SIGTRAP if we're single-stepping */ 1484 if (ptrace_cancel_bpt(current)) 1485 send_sig(SIGTRAP, current, 1); 1486 #endif 1487 unlock_user_struct(frame, frame_addr, 0); 1488 return env->regs[0]; 1489 1490 badframe: 1491 unlock_user_struct(frame, frame_addr, 0); 1492 force_sig(SIGSEGV /* , current */); 1493 return 0; 1494 } 1495 1496 static int do_sigframe_return_v2(CPUState *env, target_ulong frame_addr, 1497 struct target_ucontext_v2 *uc) 1498 { 1499 sigset_t host_set; 1500 1501 target_to_host_sigset(&host_set, &uc->tuc_sigmask); 1502 sigprocmask(SIG_SETMASK, &host_set, NULL); 1503 1504 if (restore_sigcontext(env, &uc->tuc_mcontext)) 1505 return 1; 1506 1507 if (do_sigaltstack(frame_addr + offsetof(struct target_ucontext_v2, tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT) 1508 return 1; 1509 1510 #if 0 1511 /* Send SIGTRAP if we're single-stepping */ 1512 if (ptrace_cancel_bpt(current)) 1513 send_sig(SIGTRAP, current, 1); 1514 #endif 1515 1516 return 0; 1517 } 1518 1519 static long do_sigreturn_v2(CPUState *env) 1520 { 1521 abi_ulong frame_addr; 1522 struct sigframe_v2 *frame; 1523 1524 /* 1525 * Since we stacked the signal on a 64-bit boundary, 1526 * then 'sp' should be word aligned here. If it's 1527 * not, then the user is trying to mess with us. 1528 */ 1529 if (env->regs[13] & 7) 1530 goto badframe; 1531 1532 frame_addr = env->regs[13]; 1533 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 1534 goto badframe; 1535 1536 if (do_sigframe_return_v2(env, frame_addr, &frame->uc)) 1537 goto badframe; 1538 1539 unlock_user_struct(frame, frame_addr, 0); 1540 return env->regs[0]; 1541 1542 badframe: 1543 unlock_user_struct(frame, frame_addr, 0); 1544 force_sig(SIGSEGV /* , current */); 1545 return 0; 1546 } 1547 1548 long do_sigreturn(CPUState *env) 1549 { 1550 if (get_osversion() >= 0x020612) { 1551 return do_sigreturn_v2(env); 1552 } else { 1553 return do_sigreturn_v1(env); 1554 } 1555 } 1556 1557 static long do_rt_sigreturn_v1(CPUState *env) 1558 { 1559 abi_ulong frame_addr; 1560 struct rt_sigframe_v1 *frame; 1561 sigset_t host_set; 1562 1563 /* 1564 * Since we stacked the signal on a 64-bit boundary, 1565 * then 'sp' should be word aligned here. If it's 1566 * not, then the user is trying to mess with us. 1567 */ 1568 if (env->regs[13] & 7) 1569 goto badframe; 1570 1571 frame_addr = env->regs[13]; 1572 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 1573 goto badframe; 1574 1575 target_to_host_sigset(&host_set, &frame->uc.tuc_sigmask); 1576 sigprocmask(SIG_SETMASK, &host_set, NULL); 1577 1578 if (restore_sigcontext(env, &frame->uc.tuc_mcontext)) 1579 goto badframe; 1580 1581 if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe_v1, uc.tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT) 1582 goto badframe; 1583 1584 #if 0 1585 /* Send SIGTRAP if we're single-stepping */ 1586 if (ptrace_cancel_bpt(current)) 1587 send_sig(SIGTRAP, current, 1); 1588 #endif 1589 unlock_user_struct(frame, frame_addr, 0); 1590 return env->regs[0]; 1591 1592 badframe: 1593 unlock_user_struct(frame, frame_addr, 0); 1594 force_sig(SIGSEGV /* , current */); 1595 return 0; 1596 } 1597 1598 static long do_rt_sigreturn_v2(CPUState *env) 1599 { 1600 abi_ulong frame_addr; 1601 struct rt_sigframe_v2 *frame; 1602 1603 /* 1604 * Since we stacked the signal on a 64-bit boundary, 1605 * then 'sp' should be word aligned here. If it's 1606 * not, then the user is trying to mess with us. 1607 */ 1608 if (env->regs[13] & 7) 1609 goto badframe; 1610 1611 frame_addr = env->regs[13]; 1612 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 1613 goto badframe; 1614 1615 if (do_sigframe_return_v2(env, frame_addr, &frame->uc)) 1616 goto badframe; 1617 1618 unlock_user_struct(frame, frame_addr, 0); 1619 return env->regs[0]; 1620 1621 badframe: 1622 unlock_user_struct(frame, frame_addr, 0); 1623 force_sig(SIGSEGV /* , current */); 1624 return 0; 1625 } 1626 1627 long do_rt_sigreturn(CPUState *env) 1628 { 1629 if (get_osversion() >= 0x020612) { 1630 return do_rt_sigreturn_v2(env); 1631 } else { 1632 return do_rt_sigreturn_v1(env); 1633 } 1634 } 1635 1636 #elif defined(TARGET_SPARC) 1637 1638 #define __SUNOS_MAXWIN 31 1639 1640 /* This is what SunOS does, so shall I. */ 1641 struct target_sigcontext { 1642 abi_ulong sigc_onstack; /* state to restore */ 1643 1644 abi_ulong sigc_mask; /* sigmask to restore */ 1645 abi_ulong sigc_sp; /* stack pointer */ 1646 abi_ulong sigc_pc; /* program counter */ 1647 abi_ulong sigc_npc; /* next program counter */ 1648 abi_ulong sigc_psr; /* for condition codes etc */ 1649 abi_ulong sigc_g1; /* User uses these two registers */ 1650 abi_ulong sigc_o0; /* within the trampoline code. */ 1651 1652 /* Now comes information regarding the users window set 1653 * at the time of the signal. 1654 */ 1655 abi_ulong sigc_oswins; /* outstanding windows */ 1656 1657 /* stack ptrs for each regwin buf */ 1658 char *sigc_spbuf[__SUNOS_MAXWIN]; 1659 1660 /* Windows to restore after signal */ 1661 struct { 1662 abi_ulong locals[8]; 1663 abi_ulong ins[8]; 1664 } sigc_wbuf[__SUNOS_MAXWIN]; 1665 }; 1666 /* A Sparc stack frame */ 1667 struct sparc_stackf { 1668 abi_ulong locals[8]; 1669 abi_ulong ins[6]; 1670 struct sparc_stackf *fp; 1671 abi_ulong callers_pc; 1672 char *structptr; 1673 abi_ulong xargs[6]; 1674 abi_ulong xxargs[1]; 1675 }; 1676 1677 typedef struct { 1678 struct { 1679 abi_ulong psr; 1680 abi_ulong pc; 1681 abi_ulong npc; 1682 abi_ulong y; 1683 abi_ulong u_regs[16]; /* globals and ins */ 1684 } si_regs; 1685 int si_mask; 1686 } __siginfo_t; 1687 1688 typedef struct { 1689 unsigned long si_float_regs [32]; 1690 unsigned long si_fsr; 1691 unsigned long si_fpqdepth; 1692 struct { 1693 unsigned long *insn_addr; 1694 unsigned long insn; 1695 } si_fpqueue [16]; 1696 } qemu_siginfo_fpu_t; 1697 1698 1699 struct target_signal_frame { 1700 struct sparc_stackf ss; 1701 __siginfo_t info; 1702 abi_ulong fpu_save; 1703 abi_ulong insns[2] __attribute__ ((aligned (8))); 1704 abi_ulong extramask[TARGET_NSIG_WORDS - 1]; 1705 abi_ulong extra_size; /* Should be 0 */ 1706 qemu_siginfo_fpu_t fpu_state; 1707 }; 1708 struct target_rt_signal_frame { 1709 struct sparc_stackf ss; 1710 siginfo_t info; 1711 abi_ulong regs[20]; 1712 sigset_t mask; 1713 abi_ulong fpu_save; 1714 unsigned int insns[2]; 1715 stack_t stack; 1716 unsigned int extra_size; /* Should be 0 */ 1717 qemu_siginfo_fpu_t fpu_state; 1718 }; 1719 1720 #define UREG_O0 16 1721 #define UREG_O6 22 1722 #define UREG_I0 0 1723 #define UREG_I1 1 1724 #define UREG_I2 2 1725 #define UREG_I3 3 1726 #define UREG_I4 4 1727 #define UREG_I5 5 1728 #define UREG_I6 6 1729 #define UREG_I7 7 1730 #define UREG_L0 8 1731 #define UREG_FP UREG_I6 1732 #define UREG_SP UREG_O6 1733 1734 static inline abi_ulong get_sigframe(struct target_sigaction *sa, 1735 CPUState *env, unsigned long framesize) 1736 { 1737 abi_ulong sp; 1738 1739 sp = env->regwptr[UREG_FP]; 1740 1741 /* This is the X/Open sanctioned signal stack switching. */ 1742 if (sa->sa_flags & TARGET_SA_ONSTACK) { 1743 if (!on_sig_stack(sp) 1744 && !((target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size) & 7)) 1745 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 1746 } 1747 return sp - framesize; 1748 } 1749 1750 static int 1751 setup___siginfo(__siginfo_t *si, CPUState *env, abi_ulong mask) 1752 { 1753 int err = 0, i; 1754 1755 err |= __put_user(env->psr, &si->si_regs.psr); 1756 err |= __put_user(env->pc, &si->si_regs.pc); 1757 err |= __put_user(env->npc, &si->si_regs.npc); 1758 err |= __put_user(env->y, &si->si_regs.y); 1759 for (i=0; i < 8; i++) { 1760 err |= __put_user(env->gregs[i], &si->si_regs.u_regs[i]); 1761 } 1762 for (i=0; i < 8; i++) { 1763 err |= __put_user(env->regwptr[UREG_I0 + i], &si->si_regs.u_regs[i+8]); 1764 } 1765 err |= __put_user(mask, &si->si_mask); 1766 return err; 1767 } 1768 1769 #if 0 1770 static int 1771 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/ 1772 CPUState *env, unsigned long mask) 1773 { 1774 int err = 0; 1775 1776 err |= __put_user(mask, &sc->sigc_mask); 1777 err |= __put_user(env->regwptr[UREG_SP], &sc->sigc_sp); 1778 err |= __put_user(env->pc, &sc->sigc_pc); 1779 err |= __put_user(env->npc, &sc->sigc_npc); 1780 err |= __put_user(env->psr, &sc->sigc_psr); 1781 err |= __put_user(env->gregs[1], &sc->sigc_g1); 1782 err |= __put_user(env->regwptr[UREG_O0], &sc->sigc_o0); 1783 1784 return err; 1785 } 1786 #endif 1787 #define NF_ALIGNEDSZ (((sizeof(struct target_signal_frame) + 7) & (~7))) 1788 1789 static void setup_frame(int sig, struct target_sigaction *ka, 1790 target_sigset_t *set, CPUState *env) 1791 { 1792 abi_ulong sf_addr; 1793 struct target_signal_frame *sf; 1794 int sigframe_size, err, i; 1795 1796 /* 1. Make sure everything is clean */ 1797 //synchronize_user_stack(); 1798 1799 sigframe_size = NF_ALIGNEDSZ; 1800 sf_addr = get_sigframe(ka, env, sigframe_size); 1801 1802 sf = lock_user(VERIFY_WRITE, sf_addr, 1803 sizeof(struct target_signal_frame), 0); 1804 if (!sf) 1805 goto sigsegv; 1806 1807 //fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]); 1808 #if 0 1809 if (invalid_frame_pointer(sf, sigframe_size)) 1810 goto sigill_and_return; 1811 #endif 1812 /* 2. Save the current process state */ 1813 err = setup___siginfo(&sf->info, env, set->sig[0]); 1814 err |= __put_user(0, &sf->extra_size); 1815 1816 //err |= save_fpu_state(regs, &sf->fpu_state); 1817 //err |= __put_user(&sf->fpu_state, &sf->fpu_save); 1818 1819 err |= __put_user(set->sig[0], &sf->info.si_mask); 1820 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) { 1821 err |= __put_user(set->sig[i + 1], &sf->extramask[i]); 1822 } 1823 1824 for (i = 0; i < 8; i++) { 1825 err |= __put_user(env->regwptr[i + UREG_L0], &sf->ss.locals[i]); 1826 } 1827 for (i = 0; i < 8; i++) { 1828 err |= __put_user(env->regwptr[i + UREG_I0], &sf->ss.ins[i]); 1829 } 1830 if (err) 1831 goto sigsegv; 1832 1833 /* 3. signal handler back-trampoline and parameters */ 1834 env->regwptr[UREG_FP] = sf_addr; 1835 env->regwptr[UREG_I0] = sig; 1836 env->regwptr[UREG_I1] = sf_addr + 1837 offsetof(struct target_signal_frame, info); 1838 env->regwptr[UREG_I2] = sf_addr + 1839 offsetof(struct target_signal_frame, info); 1840 1841 /* 4. signal handler */ 1842 env->pc = ka->_sa_handler; 1843 env->npc = (env->pc + 4); 1844 /* 5. return to kernel instructions */ 1845 if (ka->sa_restorer) 1846 env->regwptr[UREG_I7] = ka->sa_restorer; 1847 else { 1848 uint32_t val32; 1849 1850 env->regwptr[UREG_I7] = sf_addr + 1851 offsetof(struct target_signal_frame, insns) - 2 * 4; 1852 1853 /* mov __NR_sigreturn, %g1 */ 1854 val32 = 0x821020d8; 1855 err |= __put_user(val32, &sf->insns[0]); 1856 1857 /* t 0x10 */ 1858 val32 = 0x91d02010; 1859 err |= __put_user(val32, &sf->insns[1]); 1860 if (err) 1861 goto sigsegv; 1862 1863 /* Flush instruction space. */ 1864 //flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0])); 1865 // tb_flush(env); 1866 } 1867 unlock_user(sf, sf_addr, sizeof(struct target_signal_frame)); 1868 return; 1869 #if 0 1870 sigill_and_return: 1871 force_sig(TARGET_SIGILL); 1872 #endif 1873 sigsegv: 1874 //fprintf(stderr, "force_sig\n"); 1875 unlock_user(sf, sf_addr, sizeof(struct target_signal_frame)); 1876 force_sig(TARGET_SIGSEGV); 1877 } 1878 static inline int 1879 restore_fpu_state(CPUState *env, qemu_siginfo_fpu_t *fpu) 1880 { 1881 int err; 1882 #if 0 1883 #ifdef CONFIG_SMP 1884 if (current->flags & PF_USEDFPU) 1885 regs->psr &= ~PSR_EF; 1886 #else 1887 if (current == last_task_used_math) { 1888 last_task_used_math = 0; 1889 regs->psr &= ~PSR_EF; 1890 } 1891 #endif 1892 current->used_math = 1; 1893 current->flags &= ~PF_USEDFPU; 1894 #endif 1895 #if 0 1896 if (verify_area (VERIFY_READ, fpu, sizeof(*fpu))) 1897 return -EFAULT; 1898 #endif 1899 1900 #if 0 1901 /* XXX: incorrect */ 1902 err = __copy_from_user(&env->fpr[0], &fpu->si_float_regs[0], 1903 (sizeof(unsigned long) * 32)); 1904 #endif 1905 err |= __get_user(env->fsr, &fpu->si_fsr); 1906 #if 0 1907 err |= __get_user(current->thread.fpqdepth, &fpu->si_fpqdepth); 1908 if (current->thread.fpqdepth != 0) 1909 err |= __copy_from_user(¤t->thread.fpqueue[0], 1910 &fpu->si_fpqueue[0], 1911 ((sizeof(unsigned long) + 1912 (sizeof(unsigned long *)))*16)); 1913 #endif 1914 return err; 1915 } 1916 1917 1918 static void setup_rt_frame(int sig, struct target_sigaction *ka, 1919 target_siginfo_t *info, 1920 target_sigset_t *set, CPUState *env) 1921 { 1922 fprintf(stderr, "setup_rt_frame: not implemented\n"); 1923 } 1924 1925 long do_sigreturn(CPUState *env) 1926 { 1927 abi_ulong sf_addr; 1928 struct target_signal_frame *sf; 1929 uint32_t up_psr, pc, npc; 1930 target_sigset_t set; 1931 sigset_t host_set; 1932 abi_ulong fpu_save_addr; 1933 int err, i; 1934 1935 sf_addr = env->regwptr[UREG_FP]; 1936 if (!lock_user_struct(VERIFY_READ, sf, sf_addr, 1)) 1937 goto segv_and_exit; 1938 #if 0 1939 fprintf(stderr, "sigreturn\n"); 1940 fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]); 1941 #endif 1942 //cpu_dump_state(env, stderr, fprintf, 0); 1943 1944 /* 1. Make sure we are not getting garbage from the user */ 1945 1946 if (sf_addr & 3) 1947 goto segv_and_exit; 1948 1949 err = __get_user(pc, &sf->info.si_regs.pc); 1950 err |= __get_user(npc, &sf->info.si_regs.npc); 1951 1952 if ((pc | npc) & 3) 1953 goto segv_and_exit; 1954 1955 /* 2. Restore the state */ 1956 err |= __get_user(up_psr, &sf->info.si_regs.psr); 1957 1958 /* User can only change condition codes and FPU enabling in %psr. */ 1959 env->psr = (up_psr & (PSR_ICC /* | PSR_EF */)) 1960 | (env->psr & ~(PSR_ICC /* | PSR_EF */)); 1961 1962 env->pc = pc; 1963 env->npc = npc; 1964 err |= __get_user(env->y, &sf->info.si_regs.y); 1965 for (i=0; i < 8; i++) { 1966 err |= __get_user(env->gregs[i], &sf->info.si_regs.u_regs[i]); 1967 } 1968 for (i=0; i < 8; i++) { 1969 err |= __get_user(env->regwptr[i + UREG_I0], &sf->info.si_regs.u_regs[i+8]); 1970 } 1971 1972 err |= __get_user(fpu_save_addr, &sf->fpu_save); 1973 1974 //if (fpu_save) 1975 // err |= restore_fpu_state(env, fpu_save); 1976 1977 /* This is pretty much atomic, no amount locking would prevent 1978 * the races which exist anyways. 1979 */ 1980 err |= __get_user(set.sig[0], &sf->info.si_mask); 1981 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 1982 err |= (__get_user(set.sig[i], &sf->extramask[i - 1])); 1983 } 1984 1985 target_to_host_sigset_internal(&host_set, &set); 1986 sigprocmask(SIG_SETMASK, &host_set, NULL); 1987 1988 if (err) 1989 goto segv_and_exit; 1990 unlock_user_struct(sf, sf_addr, 0); 1991 return env->regwptr[0]; 1992 1993 segv_and_exit: 1994 unlock_user_struct(sf, sf_addr, 0); 1995 force_sig(TARGET_SIGSEGV); 1996 } 1997 1998 long do_rt_sigreturn(CPUState *env) 1999 { 2000 fprintf(stderr, "do_rt_sigreturn: not implemented\n"); 2001 return -TARGET_ENOSYS; 2002 } 2003 2004 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32) 2005 #define MC_TSTATE 0 2006 #define MC_PC 1 2007 #define MC_NPC 2 2008 #define MC_Y 3 2009 #define MC_G1 4 2010 #define MC_G2 5 2011 #define MC_G3 6 2012 #define MC_G4 7 2013 #define MC_G5 8 2014 #define MC_G6 9 2015 #define MC_G7 10 2016 #define MC_O0 11 2017 #define MC_O1 12 2018 #define MC_O2 13 2019 #define MC_O3 14 2020 #define MC_O4 15 2021 #define MC_O5 16 2022 #define MC_O6 17 2023 #define MC_O7 18 2024 #define MC_NGREG 19 2025 2026 typedef abi_ulong target_mc_greg_t; 2027 typedef target_mc_greg_t target_mc_gregset_t[MC_NGREG]; 2028 2029 struct target_mc_fq { 2030 abi_ulong *mcfq_addr; 2031 uint32_t mcfq_insn; 2032 }; 2033 2034 struct target_mc_fpu { 2035 union { 2036 uint32_t sregs[32]; 2037 uint64_t dregs[32]; 2038 //uint128_t qregs[16]; 2039 } mcfpu_fregs; 2040 abi_ulong mcfpu_fsr; 2041 abi_ulong mcfpu_fprs; 2042 abi_ulong mcfpu_gsr; 2043 struct target_mc_fq *mcfpu_fq; 2044 unsigned char mcfpu_qcnt; 2045 unsigned char mcfpu_qentsz; 2046 unsigned char mcfpu_enab; 2047 }; 2048 typedef struct target_mc_fpu target_mc_fpu_t; 2049 2050 typedef struct { 2051 target_mc_gregset_t mc_gregs; 2052 target_mc_greg_t mc_fp; 2053 target_mc_greg_t mc_i7; 2054 target_mc_fpu_t mc_fpregs; 2055 } target_mcontext_t; 2056 2057 struct target_ucontext { 2058 struct target_ucontext *uc_link; 2059 abi_ulong uc_flags; 2060 target_sigset_t uc_sigmask; 2061 target_mcontext_t uc_mcontext; 2062 }; 2063 2064 /* A V9 register window */ 2065 struct target_reg_window { 2066 abi_ulong locals[8]; 2067 abi_ulong ins[8]; 2068 }; 2069 2070 #define TARGET_STACK_BIAS 2047 2071 2072 /* {set, get}context() needed for 64-bit SparcLinux userland. */ 2073 void sparc64_set_context(CPUSPARCState *env) 2074 { 2075 abi_ulong ucp_addr; 2076 struct target_ucontext *ucp; 2077 target_mc_gregset_t *grp; 2078 abi_ulong pc, npc, tstate; 2079 abi_ulong fp, i7, w_addr; 2080 unsigned char fenab; 2081 int err; 2082 unsigned int i; 2083 2084 ucp_addr = env->regwptr[UREG_I0]; 2085 if (!lock_user_struct(VERIFY_READ, ucp, ucp_addr, 1)) 2086 goto do_sigsegv; 2087 grp = &ucp->uc_mcontext.mc_gregs; 2088 err = __get_user(pc, &((*grp)[MC_PC])); 2089 err |= __get_user(npc, &((*grp)[MC_NPC])); 2090 if (err || ((pc | npc) & 3)) 2091 goto do_sigsegv; 2092 if (env->regwptr[UREG_I1]) { 2093 target_sigset_t target_set; 2094 sigset_t set; 2095 2096 if (TARGET_NSIG_WORDS == 1) { 2097 if (__get_user(target_set.sig[0], &ucp->uc_sigmask.sig[0])) 2098 goto do_sigsegv; 2099 } else { 2100 abi_ulong *src, *dst; 2101 src = ucp->uc_sigmask.sig; 2102 dst = target_set.sig; 2103 for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong); 2104 i++, dst++, src++) 2105 err |= __get_user(*dst, src); 2106 if (err) 2107 goto do_sigsegv; 2108 } 2109 target_to_host_sigset_internal(&set, &target_set); 2110 sigprocmask(SIG_SETMASK, &set, NULL); 2111 } 2112 env->pc = pc; 2113 env->npc = npc; 2114 err |= __get_user(env->y, &((*grp)[MC_Y])); 2115 err |= __get_user(tstate, &((*grp)[MC_TSTATE])); 2116 env->asi = (tstate >> 24) & 0xff; 2117 PUT_CCR(env, tstate >> 32); 2118 PUT_CWP64(env, tstate & 0x1f); 2119 err |= __get_user(env->gregs[1], (&(*grp)[MC_G1])); 2120 err |= __get_user(env->gregs[2], (&(*grp)[MC_G2])); 2121 err |= __get_user(env->gregs[3], (&(*grp)[MC_G3])); 2122 err |= __get_user(env->gregs[4], (&(*grp)[MC_G4])); 2123 err |= __get_user(env->gregs[5], (&(*grp)[MC_G5])); 2124 err |= __get_user(env->gregs[6], (&(*grp)[MC_G6])); 2125 err |= __get_user(env->gregs[7], (&(*grp)[MC_G7])); 2126 err |= __get_user(env->regwptr[UREG_I0], (&(*grp)[MC_O0])); 2127 err |= __get_user(env->regwptr[UREG_I1], (&(*grp)[MC_O1])); 2128 err |= __get_user(env->regwptr[UREG_I2], (&(*grp)[MC_O2])); 2129 err |= __get_user(env->regwptr[UREG_I3], (&(*grp)[MC_O3])); 2130 err |= __get_user(env->regwptr[UREG_I4], (&(*grp)[MC_O4])); 2131 err |= __get_user(env->regwptr[UREG_I5], (&(*grp)[MC_O5])); 2132 err |= __get_user(env->regwptr[UREG_I6], (&(*grp)[MC_O6])); 2133 err |= __get_user(env->regwptr[UREG_I7], (&(*grp)[MC_O7])); 2134 2135 err |= __get_user(fp, &(ucp->uc_mcontext.mc_fp)); 2136 err |= __get_user(i7, &(ucp->uc_mcontext.mc_i7)); 2137 2138 w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6]; 2139 if (put_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]), 2140 abi_ulong) != 0) 2141 goto do_sigsegv; 2142 if (put_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]), 2143 abi_ulong) != 0) 2144 goto do_sigsegv; 2145 err |= __get_user(fenab, &(ucp->uc_mcontext.mc_fpregs.mcfpu_enab)); 2146 err |= __get_user(env->fprs, &(ucp->uc_mcontext.mc_fpregs.mcfpu_fprs)); 2147 { 2148 uint32_t *src, *dst; 2149 src = ucp->uc_mcontext.mc_fpregs.mcfpu_fregs.sregs; 2150 dst = env->fpr; 2151 /* XXX: check that the CPU storage is the same as user context */ 2152 for (i = 0; i < 64; i++, dst++, src++) 2153 err |= __get_user(*dst, src); 2154 } 2155 err |= __get_user(env->fsr, 2156 &(ucp->uc_mcontext.mc_fpregs.mcfpu_fsr)); 2157 err |= __get_user(env->gsr, 2158 &(ucp->uc_mcontext.mc_fpregs.mcfpu_gsr)); 2159 if (err) 2160 goto do_sigsegv; 2161 unlock_user_struct(ucp, ucp_addr, 0); 2162 return; 2163 do_sigsegv: 2164 unlock_user_struct(ucp, ucp_addr, 0); 2165 force_sig(SIGSEGV); 2166 } 2167 2168 void sparc64_get_context(CPUSPARCState *env) 2169 { 2170 abi_ulong ucp_addr; 2171 struct target_ucontext *ucp; 2172 target_mc_gregset_t *grp; 2173 target_mcontext_t *mcp; 2174 abi_ulong fp, i7, w_addr; 2175 int err; 2176 unsigned int i; 2177 target_sigset_t target_set; 2178 sigset_t set; 2179 2180 ucp_addr = env->regwptr[UREG_I0]; 2181 if (!lock_user_struct(VERIFY_WRITE, ucp, ucp_addr, 0)) 2182 goto do_sigsegv; 2183 2184 mcp = &ucp->uc_mcontext; 2185 grp = &mcp->mc_gregs; 2186 2187 /* Skip over the trap instruction, first. */ 2188 env->pc = env->npc; 2189 env->npc += 4; 2190 2191 err = 0; 2192 2193 sigprocmask(0, NULL, &set); 2194 host_to_target_sigset_internal(&target_set, &set); 2195 if (TARGET_NSIG_WORDS == 1) { 2196 err |= __put_user(target_set.sig[0], 2197 (abi_ulong *)&ucp->uc_sigmask); 2198 } else { 2199 abi_ulong *src, *dst; 2200 src = target_set.sig; 2201 dst = ucp->uc_sigmask.sig; 2202 for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong); 2203 i++, dst++, src++) 2204 err |= __put_user(*src, dst); 2205 if (err) 2206 goto do_sigsegv; 2207 } 2208 2209 /* XXX: tstate must be saved properly */ 2210 // err |= __put_user(env->tstate, &((*grp)[MC_TSTATE])); 2211 err |= __put_user(env->pc, &((*grp)[MC_PC])); 2212 err |= __put_user(env->npc, &((*grp)[MC_NPC])); 2213 err |= __put_user(env->y, &((*grp)[MC_Y])); 2214 err |= __put_user(env->gregs[1], &((*grp)[MC_G1])); 2215 err |= __put_user(env->gregs[2], &((*grp)[MC_G2])); 2216 err |= __put_user(env->gregs[3], &((*grp)[MC_G3])); 2217 err |= __put_user(env->gregs[4], &((*grp)[MC_G4])); 2218 err |= __put_user(env->gregs[5], &((*grp)[MC_G5])); 2219 err |= __put_user(env->gregs[6], &((*grp)[MC_G6])); 2220 err |= __put_user(env->gregs[7], &((*grp)[MC_G7])); 2221 err |= __put_user(env->regwptr[UREG_I0], &((*grp)[MC_O0])); 2222 err |= __put_user(env->regwptr[UREG_I1], &((*grp)[MC_O1])); 2223 err |= __put_user(env->regwptr[UREG_I2], &((*grp)[MC_O2])); 2224 err |= __put_user(env->regwptr[UREG_I3], &((*grp)[MC_O3])); 2225 err |= __put_user(env->regwptr[UREG_I4], &((*grp)[MC_O4])); 2226 err |= __put_user(env->regwptr[UREG_I5], &((*grp)[MC_O5])); 2227 err |= __put_user(env->regwptr[UREG_I6], &((*grp)[MC_O6])); 2228 err |= __put_user(env->regwptr[UREG_I7], &((*grp)[MC_O7])); 2229 2230 w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6]; 2231 fp = i7 = 0; 2232 if (get_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]), 2233 abi_ulong) != 0) 2234 goto do_sigsegv; 2235 if (get_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]), 2236 abi_ulong) != 0) 2237 goto do_sigsegv; 2238 err |= __put_user(fp, &(mcp->mc_fp)); 2239 err |= __put_user(i7, &(mcp->mc_i7)); 2240 2241 { 2242 uint32_t *src, *dst; 2243 src = env->fpr; 2244 dst = ucp->uc_mcontext.mc_fpregs.mcfpu_fregs.sregs; 2245 /* XXX: check that the CPU storage is the same as user context */ 2246 for (i = 0; i < 64; i++, dst++, src++) 2247 err |= __put_user(*src, dst); 2248 } 2249 err |= __put_user(env->fsr, &(mcp->mc_fpregs.mcfpu_fsr)); 2250 err |= __put_user(env->gsr, &(mcp->mc_fpregs.mcfpu_gsr)); 2251 err |= __put_user(env->fprs, &(mcp->mc_fpregs.mcfpu_fprs)); 2252 2253 if (err) 2254 goto do_sigsegv; 2255 unlock_user_struct(ucp, ucp_addr, 1); 2256 return; 2257 do_sigsegv: 2258 unlock_user_struct(ucp, ucp_addr, 1); 2259 force_sig(SIGSEGV); 2260 } 2261 #endif 2262 #elif defined(TARGET_ABI_MIPSN64) 2263 2264 # warning signal handling not implemented 2265 2266 static void setup_frame(int sig, struct target_sigaction *ka, 2267 target_sigset_t *set, CPUState *env) 2268 { 2269 fprintf(stderr, "setup_frame: not implemented\n"); 2270 } 2271 2272 static void setup_rt_frame(int sig, struct target_sigaction *ka, 2273 target_siginfo_t *info, 2274 target_sigset_t *set, CPUState *env) 2275 { 2276 fprintf(stderr, "setup_rt_frame: not implemented\n"); 2277 } 2278 2279 long do_sigreturn(CPUState *env) 2280 { 2281 fprintf(stderr, "do_sigreturn: not implemented\n"); 2282 return -TARGET_ENOSYS; 2283 } 2284 2285 long do_rt_sigreturn(CPUState *env) 2286 { 2287 fprintf(stderr, "do_rt_sigreturn: not implemented\n"); 2288 return -TARGET_ENOSYS; 2289 } 2290 2291 #elif defined(TARGET_ABI_MIPSN32) 2292 2293 # warning signal handling not implemented 2294 2295 static void setup_frame(int sig, struct target_sigaction *ka, 2296 target_sigset_t *set, CPUState *env) 2297 { 2298 fprintf(stderr, "setup_frame: not implemented\n"); 2299 } 2300 2301 static void setup_rt_frame(int sig, struct target_sigaction *ka, 2302 target_siginfo_t *info, 2303 target_sigset_t *set, CPUState *env) 2304 { 2305 fprintf(stderr, "setup_rt_frame: not implemented\n"); 2306 } 2307 2308 long do_sigreturn(CPUState *env) 2309 { 2310 fprintf(stderr, "do_sigreturn: not implemented\n"); 2311 return -TARGET_ENOSYS; 2312 } 2313 2314 long do_rt_sigreturn(CPUState *env) 2315 { 2316 fprintf(stderr, "do_rt_sigreturn: not implemented\n"); 2317 return -TARGET_ENOSYS; 2318 } 2319 2320 #elif defined(TARGET_ABI_MIPSO32) 2321 2322 struct target_sigcontext { 2323 uint32_t sc_regmask; /* Unused */ 2324 uint32_t sc_status; 2325 uint64_t sc_pc; 2326 uint64_t sc_regs[32]; 2327 uint64_t sc_fpregs[32]; 2328 uint32_t sc_ownedfp; /* Unused */ 2329 uint32_t sc_fpc_csr; 2330 uint32_t sc_fpc_eir; /* Unused */ 2331 uint32_t sc_used_math; 2332 uint32_t sc_dsp; /* dsp status, was sc_ssflags */ 2333 uint64_t sc_mdhi; 2334 uint64_t sc_mdlo; 2335 target_ulong sc_hi1; /* Was sc_cause */ 2336 target_ulong sc_lo1; /* Was sc_badvaddr */ 2337 target_ulong sc_hi2; /* Was sc_sigset[4] */ 2338 target_ulong sc_lo2; 2339 target_ulong sc_hi3; 2340 target_ulong sc_lo3; 2341 }; 2342 2343 struct sigframe { 2344 uint32_t sf_ass[4]; /* argument save space for o32 */ 2345 uint32_t sf_code[2]; /* signal trampoline */ 2346 struct target_sigcontext sf_sc; 2347 target_sigset_t sf_mask; 2348 }; 2349 2350 struct target_ucontext { 2351 target_ulong uc_flags; 2352 target_ulong uc_link; 2353 target_stack_t uc_stack; 2354 struct target_sigcontext uc_mcontext; 2355 target_sigset_t uc_sigmask; 2356 }; 2357 2358 struct target_rt_sigframe { 2359 uint32_t rs_ass[4]; /* argument save space for o32 */ 2360 uint32_t rs_code[2]; /* signal trampoline */ 2361 struct target_siginfo rs_info; 2362 struct target_ucontext rs_uc; 2363 }; 2364 2365 /* Install trampoline to jump back from signal handler */ 2366 static inline int install_sigtramp(unsigned int *tramp, unsigned int syscall) 2367 { 2368 int err; 2369 2370 /* 2371 * Set up the return code ... 2372 * 2373 * li v0, __NR__foo_sigreturn 2374 * syscall 2375 */ 2376 2377 err = __put_user(0x24020000 + syscall, tramp + 0); 2378 err |= __put_user(0x0000000c , tramp + 1); 2379 /* flush_cache_sigtramp((unsigned long) tramp); */ 2380 return err; 2381 } 2382 2383 static inline int 2384 setup_sigcontext(CPUState *regs, struct target_sigcontext *sc) 2385 { 2386 int err = 0; 2387 2388 err |= __put_user(regs->active_tc.PC, &sc->sc_pc); 2389 2390 #define save_gp_reg(i) do { \ 2391 err |= __put_user(regs->active_tc.gpr[i], &sc->sc_regs[i]); \ 2392 } while(0) 2393 __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2); 2394 save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6); 2395 save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10); 2396 save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14); 2397 save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18); 2398 save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22); 2399 save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26); 2400 save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30); 2401 save_gp_reg(31); 2402 #undef save_gp_reg 2403 2404 err |= __put_user(regs->active_tc.HI[0], &sc->sc_mdhi); 2405 err |= __put_user(regs->active_tc.LO[0], &sc->sc_mdlo); 2406 2407 /* Not used yet, but might be useful if we ever have DSP suppport */ 2408 #if 0 2409 if (cpu_has_dsp) { 2410 err |= __put_user(mfhi1(), &sc->sc_hi1); 2411 err |= __put_user(mflo1(), &sc->sc_lo1); 2412 err |= __put_user(mfhi2(), &sc->sc_hi2); 2413 err |= __put_user(mflo2(), &sc->sc_lo2); 2414 err |= __put_user(mfhi3(), &sc->sc_hi3); 2415 err |= __put_user(mflo3(), &sc->sc_lo3); 2416 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp); 2417 } 2418 /* same with 64 bit */ 2419 #ifdef CONFIG_64BIT 2420 err |= __put_user(regs->hi, &sc->sc_hi[0]); 2421 err |= __put_user(regs->lo, &sc->sc_lo[0]); 2422 if (cpu_has_dsp) { 2423 err |= __put_user(mfhi1(), &sc->sc_hi[1]); 2424 err |= __put_user(mflo1(), &sc->sc_lo[1]); 2425 err |= __put_user(mfhi2(), &sc->sc_hi[2]); 2426 err |= __put_user(mflo2(), &sc->sc_lo[2]); 2427 err |= __put_user(mfhi3(), &sc->sc_hi[3]); 2428 err |= __put_user(mflo3(), &sc->sc_lo[3]); 2429 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp); 2430 } 2431 #endif 2432 #endif 2433 2434 #if 0 2435 err |= __put_user(!!used_math(), &sc->sc_used_math); 2436 2437 if (!used_math()) 2438 goto out; 2439 2440 /* 2441 * Save FPU state to signal context. Signal handler will "inherit" 2442 * current FPU state. 2443 */ 2444 preempt_disable(); 2445 2446 if (!is_fpu_owner()) { 2447 own_fpu(); 2448 restore_fp(current); 2449 } 2450 err |= save_fp_context(sc); 2451 2452 preempt_enable(); 2453 out: 2454 #endif 2455 return err; 2456 } 2457 2458 static inline int 2459 restore_sigcontext(CPUState *regs, struct target_sigcontext *sc) 2460 { 2461 int err = 0; 2462 2463 err |= __get_user(regs->CP0_EPC, &sc->sc_pc); 2464 2465 err |= __get_user(regs->active_tc.HI[0], &sc->sc_mdhi); 2466 err |= __get_user(regs->active_tc.LO[0], &sc->sc_mdlo); 2467 2468 #define restore_gp_reg(i) do { \ 2469 err |= __get_user(regs->active_tc.gpr[i], &sc->sc_regs[i]); \ 2470 } while(0) 2471 restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3); 2472 restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6); 2473 restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9); 2474 restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12); 2475 restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15); 2476 restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18); 2477 restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21); 2478 restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24); 2479 restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27); 2480 restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30); 2481 restore_gp_reg(31); 2482 #undef restore_gp_reg 2483 2484 #if 0 2485 if (cpu_has_dsp) { 2486 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg); 2487 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg); 2488 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg); 2489 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg); 2490 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg); 2491 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg); 2492 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK); 2493 } 2494 #ifdef CONFIG_64BIT 2495 err |= __get_user(regs->hi, &sc->sc_hi[0]); 2496 err |= __get_user(regs->lo, &sc->sc_lo[0]); 2497 if (cpu_has_dsp) { 2498 err |= __get_user(treg, &sc->sc_hi[1]); mthi1(treg); 2499 err |= __get_user(treg, &sc->sc_lo[1]); mthi1(treg); 2500 err |= __get_user(treg, &sc->sc_hi[2]); mthi2(treg); 2501 err |= __get_user(treg, &sc->sc_lo[2]); mthi2(treg); 2502 err |= __get_user(treg, &sc->sc_hi[3]); mthi3(treg); 2503 err |= __get_user(treg, &sc->sc_lo[3]); mthi3(treg); 2504 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK); 2505 } 2506 #endif 2507 2508 err |= __get_user(used_math, &sc->sc_used_math); 2509 conditional_used_math(used_math); 2510 2511 preempt_disable(); 2512 2513 if (used_math()) { 2514 /* restore fpu context if we have used it before */ 2515 own_fpu(); 2516 err |= restore_fp_context(sc); 2517 } else { 2518 /* signal handler may have used FPU. Give it up. */ 2519 lose_fpu(); 2520 } 2521 2522 preempt_enable(); 2523 #endif 2524 return err; 2525 } 2526 /* 2527 * Determine which stack to use.. 2528 */ 2529 static inline abi_ulong 2530 get_sigframe(struct target_sigaction *ka, CPUState *regs, size_t frame_size) 2531 { 2532 unsigned long sp; 2533 2534 /* Default to using normal stack */ 2535 sp = regs->active_tc.gpr[29]; 2536 2537 /* 2538 * FPU emulator may have it's own trampoline active just 2539 * above the user stack, 16-bytes before the next lowest 2540 * 16 byte boundary. Try to avoid trashing it. 2541 */ 2542 sp -= 32; 2543 2544 /* This is the X/Open sanctioned signal stack switching. */ 2545 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) { 2546 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 2547 } 2548 2549 return (sp - frame_size) & ~7; 2550 } 2551 2552 /* compare linux/arch/mips/kernel/signal.c:setup_frame() */ 2553 static void setup_frame(int sig, struct target_sigaction * ka, 2554 target_sigset_t *set, CPUState *regs) 2555 { 2556 struct sigframe *frame; 2557 abi_ulong frame_addr; 2558 int i; 2559 2560 frame_addr = get_sigframe(ka, regs, sizeof(*frame)); 2561 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 2562 goto give_sigsegv; 2563 2564 install_sigtramp(frame->sf_code, TARGET_NR_sigreturn); 2565 2566 if(setup_sigcontext(regs, &frame->sf_sc)) 2567 goto give_sigsegv; 2568 2569 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 2570 if(__put_user(set->sig[i], &frame->sf_mask.sig[i])) 2571 goto give_sigsegv; 2572 } 2573 2574 /* 2575 * Arguments to signal handler: 2576 * 2577 * a0 = signal number 2578 * a1 = 0 (should be cause) 2579 * a2 = pointer to struct sigcontext 2580 * 2581 * $25 and PC point to the signal handler, $29 points to the 2582 * struct sigframe. 2583 */ 2584 regs->active_tc.gpr[ 4] = sig; 2585 regs->active_tc.gpr[ 5] = 0; 2586 regs->active_tc.gpr[ 6] = frame_addr + offsetof(struct sigframe, sf_sc); 2587 regs->active_tc.gpr[29] = frame_addr; 2588 regs->active_tc.gpr[31] = frame_addr + offsetof(struct sigframe, sf_code); 2589 /* The original kernel code sets CP0_EPC to the handler 2590 * since it returns to userland using eret 2591 * we cannot do this here, and we must set PC directly */ 2592 regs->active_tc.PC = regs->active_tc.gpr[25] = ka->_sa_handler; 2593 unlock_user_struct(frame, frame_addr, 1); 2594 return; 2595 2596 give_sigsegv: 2597 unlock_user_struct(frame, frame_addr, 1); 2598 force_sig(TARGET_SIGSEGV/*, current*/); 2599 return; 2600 } 2601 2602 long do_sigreturn(CPUState *regs) 2603 { 2604 struct sigframe *frame; 2605 abi_ulong frame_addr; 2606 sigset_t blocked; 2607 target_sigset_t target_set; 2608 int i; 2609 2610 #if defined(DEBUG_SIGNAL) 2611 fprintf(stderr, "do_sigreturn\n"); 2612 #endif 2613 frame_addr = regs->active_tc.gpr[29]; 2614 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 2615 goto badframe; 2616 2617 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 2618 if(__get_user(target_set.sig[i], &frame->sf_mask.sig[i])) 2619 goto badframe; 2620 } 2621 2622 target_to_host_sigset_internal(&blocked, &target_set); 2623 sigprocmask(SIG_SETMASK, &blocked, NULL); 2624 2625 if (restore_sigcontext(regs, &frame->sf_sc)) 2626 goto badframe; 2627 2628 #if 0 2629 /* 2630 * Don't let your children do this ... 2631 */ 2632 __asm__ __volatile__( 2633 "move\t$29, %0\n\t" 2634 "j\tsyscall_exit" 2635 :/* no outputs */ 2636 :"r" (®s)); 2637 /* Unreached */ 2638 #endif 2639 2640 regs->active_tc.PC = regs->CP0_EPC; 2641 /* I am not sure this is right, but it seems to work 2642 * maybe a problem with nested signals ? */ 2643 regs->CP0_EPC = 0; 2644 return -TARGET_QEMU_ESIGRETURN; 2645 2646 badframe: 2647 force_sig(TARGET_SIGSEGV/*, current*/); 2648 return 0; 2649 } 2650 2651 static void setup_rt_frame(int sig, struct target_sigaction *ka, 2652 target_siginfo_t *info, 2653 target_sigset_t *set, CPUState *env) 2654 { 2655 struct target_rt_sigframe *frame; 2656 abi_ulong frame_addr; 2657 int i; 2658 2659 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 2660 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 2661 goto give_sigsegv; 2662 2663 install_sigtramp(frame->rs_code, TARGET_NR_rt_sigreturn); 2664 2665 copy_siginfo_to_user(&frame->rs_info, info); 2666 2667 __put_user(0, &frame->rs_uc.uc_flags); 2668 __put_user(0, &frame->rs_uc.uc_link); 2669 __put_user(target_sigaltstack_used.ss_sp, &frame->rs_uc.uc_stack.ss_sp); 2670 __put_user(target_sigaltstack_used.ss_size, &frame->rs_uc.uc_stack.ss_size); 2671 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), 2672 &frame->rs_uc.uc_stack.ss_flags); 2673 2674 setup_sigcontext(env, &frame->rs_uc.uc_mcontext); 2675 2676 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 2677 __put_user(set->sig[i], &frame->rs_uc.uc_sigmask.sig[i]); 2678 } 2679 2680 /* 2681 * Arguments to signal handler: 2682 * 2683 * a0 = signal number 2684 * a1 = pointer to struct siginfo 2685 * a2 = pointer to struct ucontext 2686 * 2687 * $25 and PC point to the signal handler, $29 points to the 2688 * struct sigframe. 2689 */ 2690 env->active_tc.gpr[ 4] = sig; 2691 env->active_tc.gpr[ 5] = frame_addr 2692 + offsetof(struct target_rt_sigframe, rs_info); 2693 env->active_tc.gpr[ 6] = frame_addr 2694 + offsetof(struct target_rt_sigframe, rs_uc); 2695 env->active_tc.gpr[29] = frame_addr; 2696 env->active_tc.gpr[31] = frame_addr 2697 + offsetof(struct target_rt_sigframe, rs_code); 2698 /* The original kernel code sets CP0_EPC to the handler 2699 * since it returns to userland using eret 2700 * we cannot do this here, and we must set PC directly */ 2701 env->active_tc.PC = env->active_tc.gpr[25] = ka->_sa_handler; 2702 unlock_user_struct(frame, frame_addr, 1); 2703 return; 2704 2705 give_sigsegv: 2706 unlock_user_struct(frame, frame_addr, 1); 2707 force_sig(TARGET_SIGSEGV/*, current*/); 2708 return; 2709 } 2710 2711 long do_rt_sigreturn(CPUState *env) 2712 { 2713 struct target_rt_sigframe *frame; 2714 abi_ulong frame_addr; 2715 sigset_t blocked; 2716 2717 #if defined(DEBUG_SIGNAL) 2718 fprintf(stderr, "do_rt_sigreturn\n"); 2719 #endif 2720 frame_addr = env->active_tc.gpr[29]; 2721 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 2722 goto badframe; 2723 2724 target_to_host_sigset(&blocked, &frame->rs_uc.uc_sigmask); 2725 sigprocmask(SIG_SETMASK, &blocked, NULL); 2726 2727 if (restore_sigcontext(env, &frame->rs_uc.uc_mcontext)) 2728 goto badframe; 2729 2730 if (do_sigaltstack(frame_addr + 2731 offsetof(struct target_rt_sigframe, rs_uc.uc_stack), 2732 0, get_sp_from_cpustate(env)) == -EFAULT) 2733 goto badframe; 2734 2735 env->active_tc.PC = env->CP0_EPC; 2736 /* I am not sure this is right, but it seems to work 2737 * maybe a problem with nested signals ? */ 2738 env->CP0_EPC = 0; 2739 return -TARGET_QEMU_ESIGRETURN; 2740 2741 badframe: 2742 force_sig(TARGET_SIGSEGV/*, current*/); 2743 return 0; 2744 } 2745 2746 #elif defined(TARGET_SH4) 2747 2748 /* 2749 * code and data structures from linux kernel: 2750 * include/asm-sh/sigcontext.h 2751 * arch/sh/kernel/signal.c 2752 */ 2753 2754 struct target_sigcontext { 2755 target_ulong oldmask; 2756 2757 /* CPU registers */ 2758 target_ulong sc_gregs[16]; 2759 target_ulong sc_pc; 2760 target_ulong sc_pr; 2761 target_ulong sc_sr; 2762 target_ulong sc_gbr; 2763 target_ulong sc_mach; 2764 target_ulong sc_macl; 2765 2766 /* FPU registers */ 2767 target_ulong sc_fpregs[16]; 2768 target_ulong sc_xfpregs[16]; 2769 unsigned int sc_fpscr; 2770 unsigned int sc_fpul; 2771 unsigned int sc_ownedfp; 2772 }; 2773 2774 struct target_sigframe 2775 { 2776 struct target_sigcontext sc; 2777 target_ulong extramask[TARGET_NSIG_WORDS-1]; 2778 uint16_t retcode[3]; 2779 }; 2780 2781 2782 struct target_ucontext { 2783 target_ulong uc_flags; 2784 struct target_ucontext *uc_link; 2785 target_stack_t uc_stack; 2786 struct target_sigcontext uc_mcontext; 2787 target_sigset_t uc_sigmask; /* mask last for extensibility */ 2788 }; 2789 2790 struct target_rt_sigframe 2791 { 2792 struct target_siginfo info; 2793 struct target_ucontext uc; 2794 uint16_t retcode[3]; 2795 }; 2796 2797 2798 #define MOVW(n) (0x9300|((n)-2)) /* Move mem word at PC+n to R3 */ 2799 #define TRAP_NOARG 0xc310 /* Syscall w/no args (NR in R3) SH3/4 */ 2800 2801 static abi_ulong get_sigframe(struct target_sigaction *ka, 2802 unsigned long sp, size_t frame_size) 2803 { 2804 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags(sp) == 0)) { 2805 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 2806 } 2807 2808 return (sp - frame_size) & -8ul; 2809 } 2810 2811 static int setup_sigcontext(struct target_sigcontext *sc, 2812 CPUState *regs, unsigned long mask) 2813 { 2814 int err = 0; 2815 2816 #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x) 2817 COPY(gregs[0]); COPY(gregs[1]); 2818 COPY(gregs[2]); COPY(gregs[3]); 2819 COPY(gregs[4]); COPY(gregs[5]); 2820 COPY(gregs[6]); COPY(gregs[7]); 2821 COPY(gregs[8]); COPY(gregs[9]); 2822 COPY(gregs[10]); COPY(gregs[11]); 2823 COPY(gregs[12]); COPY(gregs[13]); 2824 COPY(gregs[14]); COPY(gregs[15]); 2825 COPY(gbr); COPY(mach); 2826 COPY(macl); COPY(pr); 2827 COPY(sr); COPY(pc); 2828 #undef COPY 2829 2830 /* todo: save FPU registers here */ 2831 2832 /* non-iBCS2 extensions.. */ 2833 err |= __put_user(mask, &sc->oldmask); 2834 2835 return err; 2836 } 2837 2838 static int restore_sigcontext(CPUState *regs, 2839 struct target_sigcontext *sc) 2840 { 2841 unsigned int err = 0; 2842 2843 #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x) 2844 COPY(gregs[1]); 2845 COPY(gregs[2]); COPY(gregs[3]); 2846 COPY(gregs[4]); COPY(gregs[5]); 2847 COPY(gregs[6]); COPY(gregs[7]); 2848 COPY(gregs[8]); COPY(gregs[9]); 2849 COPY(gregs[10]); COPY(gregs[11]); 2850 COPY(gregs[12]); COPY(gregs[13]); 2851 COPY(gregs[14]); COPY(gregs[15]); 2852 COPY(gbr); COPY(mach); 2853 COPY(macl); COPY(pr); 2854 COPY(sr); COPY(pc); 2855 #undef COPY 2856 2857 /* todo: restore FPU registers here */ 2858 2859 regs->tra = -1; /* disable syscall checks */ 2860 return err; 2861 } 2862 2863 static void setup_frame(int sig, struct target_sigaction *ka, 2864 target_sigset_t *set, CPUState *regs) 2865 { 2866 struct target_sigframe *frame; 2867 abi_ulong frame_addr; 2868 int i; 2869 int err = 0; 2870 int signal; 2871 2872 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame)); 2873 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 2874 goto give_sigsegv; 2875 2876 signal = current_exec_domain_sig(sig); 2877 2878 err |= setup_sigcontext(&frame->sc, regs, set->sig[0]); 2879 2880 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) { 2881 err |= __put_user(set->sig[i + 1], &frame->extramask[i]); 2882 } 2883 2884 /* Set up to return from userspace. If provided, use a stub 2885 already in userspace. */ 2886 if (ka->sa_flags & TARGET_SA_RESTORER) { 2887 regs->pr = (unsigned long) ka->sa_restorer; 2888 } else { 2889 /* Generate return code (system call to sigreturn) */ 2890 err |= __put_user(MOVW(2), &frame->retcode[0]); 2891 err |= __put_user(TRAP_NOARG, &frame->retcode[1]); 2892 err |= __put_user((TARGET_NR_sigreturn), &frame->retcode[2]); 2893 regs->pr = (unsigned long) frame->retcode; 2894 } 2895 2896 if (err) 2897 goto give_sigsegv; 2898 2899 /* Set up registers for signal handler */ 2900 regs->gregs[15] = (unsigned long) frame; 2901 regs->gregs[4] = signal; /* Arg for signal handler */ 2902 regs->gregs[5] = 0; 2903 regs->gregs[6] = (unsigned long) &frame->sc; 2904 regs->pc = (unsigned long) ka->_sa_handler; 2905 2906 unlock_user_struct(frame, frame_addr, 1); 2907 return; 2908 2909 give_sigsegv: 2910 unlock_user_struct(frame, frame_addr, 1); 2911 force_sig(SIGSEGV); 2912 } 2913 2914 static void setup_rt_frame(int sig, struct target_sigaction *ka, 2915 target_siginfo_t *info, 2916 target_sigset_t *set, CPUState *regs) 2917 { 2918 struct target_rt_sigframe *frame; 2919 abi_ulong frame_addr; 2920 int i; 2921 int err = 0; 2922 int signal; 2923 2924 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame)); 2925 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 2926 goto give_sigsegv; 2927 2928 signal = current_exec_domain_sig(sig); 2929 2930 err |= copy_siginfo_to_user(&frame->info, info); 2931 2932 /* Create the ucontext. */ 2933 err |= __put_user(0, &frame->uc.uc_flags); 2934 err |= __put_user(0, (unsigned long *)&frame->uc.uc_link); 2935 err |= __put_user((unsigned long)target_sigaltstack_used.ss_sp, 2936 &frame->uc.uc_stack.ss_sp); 2937 err |= __put_user(sas_ss_flags(regs->gregs[15]), 2938 &frame->uc.uc_stack.ss_flags); 2939 err |= __put_user(target_sigaltstack_used.ss_size, 2940 &frame->uc.uc_stack.ss_size); 2941 err |= setup_sigcontext(&frame->uc.uc_mcontext, 2942 regs, set->sig[0]); 2943 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 2944 err |= __put_user(set->sig[i], &frame->uc.uc_sigmask.sig[i]); 2945 } 2946 2947 /* Set up to return from userspace. If provided, use a stub 2948 already in userspace. */ 2949 if (ka->sa_flags & TARGET_SA_RESTORER) { 2950 regs->pr = (unsigned long) ka->sa_restorer; 2951 } else { 2952 /* Generate return code (system call to sigreturn) */ 2953 err |= __put_user(MOVW(2), &frame->retcode[0]); 2954 err |= __put_user(TRAP_NOARG, &frame->retcode[1]); 2955 err |= __put_user((TARGET_NR_rt_sigreturn), &frame->retcode[2]); 2956 regs->pr = (unsigned long) frame->retcode; 2957 } 2958 2959 if (err) 2960 goto give_sigsegv; 2961 2962 /* Set up registers for signal handler */ 2963 regs->gregs[15] = (unsigned long) frame; 2964 regs->gregs[4] = signal; /* Arg for signal handler */ 2965 regs->gregs[5] = (unsigned long) &frame->info; 2966 regs->gregs[6] = (unsigned long) &frame->uc; 2967 regs->pc = (unsigned long) ka->_sa_handler; 2968 2969 unlock_user_struct(frame, frame_addr, 1); 2970 return; 2971 2972 give_sigsegv: 2973 unlock_user_struct(frame, frame_addr, 1); 2974 force_sig(SIGSEGV); 2975 } 2976 2977 long do_sigreturn(CPUState *regs) 2978 { 2979 struct target_sigframe *frame; 2980 abi_ulong frame_addr; 2981 sigset_t blocked; 2982 target_sigset_t target_set; 2983 int i; 2984 int err = 0; 2985 2986 #if defined(DEBUG_SIGNAL) 2987 fprintf(stderr, "do_sigreturn\n"); 2988 #endif 2989 frame_addr = regs->gregs[15]; 2990 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 2991 goto badframe; 2992 2993 err |= __get_user(target_set.sig[0], &frame->sc.oldmask); 2994 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 2995 err |= (__get_user(target_set.sig[i], &frame->extramask[i - 1])); 2996 } 2997 2998 if (err) 2999 goto badframe; 3000 3001 target_to_host_sigset_internal(&blocked, &target_set); 3002 sigprocmask(SIG_SETMASK, &blocked, NULL); 3003 3004 if (restore_sigcontext(regs, &frame->sc)) 3005 goto badframe; 3006 3007 unlock_user_struct(frame, frame_addr, 0); 3008 return regs->gregs[0]; 3009 3010 badframe: 3011 unlock_user_struct(frame, frame_addr, 0); 3012 force_sig(TARGET_SIGSEGV); 3013 return 0; 3014 } 3015 3016 long do_rt_sigreturn(CPUState *regs) 3017 { 3018 struct target_rt_sigframe *frame; 3019 abi_ulong frame_addr; 3020 sigset_t blocked; 3021 3022 #if defined(DEBUG_SIGNAL) 3023 fprintf(stderr, "do_rt_sigreturn\n"); 3024 #endif 3025 frame_addr = regs->gregs[15]; 3026 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 3027 goto badframe; 3028 3029 target_to_host_sigset(&blocked, &frame->uc.uc_sigmask); 3030 sigprocmask(SIG_SETMASK, &blocked, NULL); 3031 3032 if (restore_sigcontext(regs, &frame->uc.uc_mcontext)) 3033 goto badframe; 3034 3035 if (do_sigaltstack(frame_addr + 3036 offsetof(struct target_rt_sigframe, uc.uc_stack), 3037 0, get_sp_from_cpustate(regs)) == -EFAULT) 3038 goto badframe; 3039 3040 unlock_user_struct(frame, frame_addr, 0); 3041 return regs->gregs[0]; 3042 3043 badframe: 3044 unlock_user_struct(frame, frame_addr, 0); 3045 force_sig(TARGET_SIGSEGV); 3046 return 0; 3047 } 3048 #elif defined(TARGET_MICROBLAZE) 3049 3050 struct target_sigcontext { 3051 struct target_pt_regs regs; /* needs to be first */ 3052 uint32_t oldmask; 3053 }; 3054 3055 /* Signal frames. */ 3056 struct target_signal_frame { 3057 struct target_sigcontext sc; 3058 uint32_t extramask[TARGET_NSIG_WORDS - 1]; 3059 uint32_t tramp[2]; 3060 }; 3061 3062 struct rt_signal_frame { 3063 struct siginfo info; 3064 struct ucontext uc; 3065 uint32_t tramp[2]; 3066 }; 3067 3068 static void setup_sigcontext(struct target_sigcontext *sc, CPUState *env) 3069 { 3070 __put_user(env->regs[0], &sc->regs.r0); 3071 __put_user(env->regs[1], &sc->regs.r1); 3072 __put_user(env->regs[2], &sc->regs.r2); 3073 __put_user(env->regs[3], &sc->regs.r3); 3074 __put_user(env->regs[4], &sc->regs.r4); 3075 __put_user(env->regs[5], &sc->regs.r5); 3076 __put_user(env->regs[6], &sc->regs.r6); 3077 __put_user(env->regs[7], &sc->regs.r7); 3078 __put_user(env->regs[8], &sc->regs.r8); 3079 __put_user(env->regs[9], &sc->regs.r9); 3080 __put_user(env->regs[10], &sc->regs.r10); 3081 __put_user(env->regs[11], &sc->regs.r11); 3082 __put_user(env->regs[12], &sc->regs.r12); 3083 __put_user(env->regs[13], &sc->regs.r13); 3084 __put_user(env->regs[14], &sc->regs.r14); 3085 __put_user(env->regs[15], &sc->regs.r15); 3086 __put_user(env->regs[16], &sc->regs.r16); 3087 __put_user(env->regs[17], &sc->regs.r17); 3088 __put_user(env->regs[18], &sc->regs.r18); 3089 __put_user(env->regs[19], &sc->regs.r19); 3090 __put_user(env->regs[20], &sc->regs.r20); 3091 __put_user(env->regs[21], &sc->regs.r21); 3092 __put_user(env->regs[22], &sc->regs.r22); 3093 __put_user(env->regs[23], &sc->regs.r23); 3094 __put_user(env->regs[24], &sc->regs.r24); 3095 __put_user(env->regs[25], &sc->regs.r25); 3096 __put_user(env->regs[26], &sc->regs.r26); 3097 __put_user(env->regs[27], &sc->regs.r27); 3098 __put_user(env->regs[28], &sc->regs.r28); 3099 __put_user(env->regs[29], &sc->regs.r29); 3100 __put_user(env->regs[30], &sc->regs.r30); 3101 __put_user(env->regs[31], &sc->regs.r31); 3102 __put_user(env->sregs[SR_PC], &sc->regs.pc); 3103 } 3104 3105 static void restore_sigcontext(struct target_sigcontext *sc, CPUState *env) 3106 { 3107 __get_user(env->regs[0], &sc->regs.r0); 3108 __get_user(env->regs[1], &sc->regs.r1); 3109 __get_user(env->regs[2], &sc->regs.r2); 3110 __get_user(env->regs[3], &sc->regs.r3); 3111 __get_user(env->regs[4], &sc->regs.r4); 3112 __get_user(env->regs[5], &sc->regs.r5); 3113 __get_user(env->regs[6], &sc->regs.r6); 3114 __get_user(env->regs[7], &sc->regs.r7); 3115 __get_user(env->regs[8], &sc->regs.r8); 3116 __get_user(env->regs[9], &sc->regs.r9); 3117 __get_user(env->regs[10], &sc->regs.r10); 3118 __get_user(env->regs[11], &sc->regs.r11); 3119 __get_user(env->regs[12], &sc->regs.r12); 3120 __get_user(env->regs[13], &sc->regs.r13); 3121 __get_user(env->regs[14], &sc->regs.r14); 3122 __get_user(env->regs[15], &sc->regs.r15); 3123 __get_user(env->regs[16], &sc->regs.r16); 3124 __get_user(env->regs[17], &sc->regs.r17); 3125 __get_user(env->regs[18], &sc->regs.r18); 3126 __get_user(env->regs[19], &sc->regs.r19); 3127 __get_user(env->regs[20], &sc->regs.r20); 3128 __get_user(env->regs[21], &sc->regs.r21); 3129 __get_user(env->regs[22], &sc->regs.r22); 3130 __get_user(env->regs[23], &sc->regs.r23); 3131 __get_user(env->regs[24], &sc->regs.r24); 3132 __get_user(env->regs[25], &sc->regs.r25); 3133 __get_user(env->regs[26], &sc->regs.r26); 3134 __get_user(env->regs[27], &sc->regs.r27); 3135 __get_user(env->regs[28], &sc->regs.r28); 3136 __get_user(env->regs[29], &sc->regs.r29); 3137 __get_user(env->regs[30], &sc->regs.r30); 3138 __get_user(env->regs[31], &sc->regs.r31); 3139 __get_user(env->sregs[SR_PC], &sc->regs.pc); 3140 } 3141 3142 static abi_ulong get_sigframe(struct target_sigaction *ka, 3143 CPUState *env, int frame_size) 3144 { 3145 abi_ulong sp = env->regs[1]; 3146 3147 if ((ka->sa_flags & SA_ONSTACK) != 0 && !on_sig_stack(sp)) 3148 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 3149 3150 return ((sp - frame_size) & -8UL); 3151 } 3152 3153 static void setup_frame(int sig, struct target_sigaction *ka, 3154 target_sigset_t *set, CPUState *env) 3155 { 3156 struct target_signal_frame *frame; 3157 abi_ulong frame_addr; 3158 int err = 0; 3159 int i; 3160 3161 frame_addr = get_sigframe(ka, env, sizeof *frame); 3162 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 3163 goto badframe; 3164 3165 /* Save the mask. */ 3166 err |= __put_user(set->sig[0], &frame->sc.oldmask); 3167 if (err) 3168 goto badframe; 3169 3170 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 3171 if (__put_user(set->sig[i], &frame->extramask[i - 1])) 3172 goto badframe; 3173 } 3174 3175 setup_sigcontext(&frame->sc, env); 3176 3177 /* Set up to return from userspace. If provided, use a stub 3178 already in userspace. */ 3179 /* minus 8 is offset to cater for "rtsd r15,8" offset */ 3180 if (ka->sa_flags & TARGET_SA_RESTORER) { 3181 env->regs[15] = ((unsigned long)ka->sa_restorer)-8; 3182 } else { 3183 uint32_t t; 3184 /* Note, these encodings are _big endian_! */ 3185 /* addi r12, r0, __NR_sigreturn */ 3186 t = 0x31800000UL | TARGET_NR_sigreturn; 3187 err |= __put_user(t, frame->tramp + 0); 3188 /* brki r14, 0x8 */ 3189 t = 0xb9cc0008UL; 3190 err |= __put_user(t, frame->tramp + 1); 3191 3192 /* Return from sighandler will jump to the tramp. 3193 Negative 8 offset because return is rtsd r15, 8 */ 3194 env->regs[15] = ((unsigned long)frame->tramp) - 8; 3195 } 3196 3197 if (err) 3198 goto badframe; 3199 3200 /* Set up registers for signal handler */ 3201 env->regs[1] = (unsigned long) frame; 3202 /* Signal handler args: */ 3203 env->regs[5] = sig; /* Arg 0: signum */ 3204 env->regs[6] = (unsigned long) &frame->sc; /* arg 1: sigcontext */ 3205 3206 /* Offset of 4 to handle microblaze rtid r14, 0 */ 3207 env->sregs[SR_PC] = (unsigned long)ka->_sa_handler; 3208 3209 unlock_user_struct(frame, frame_addr, 1); 3210 return; 3211 badframe: 3212 unlock_user_struct(frame, frame_addr, 1); 3213 force_sig(TARGET_SIGSEGV); 3214 } 3215 3216 static void setup_rt_frame(int sig, struct target_sigaction *ka, 3217 target_siginfo_t *info, 3218 target_sigset_t *set, CPUState *env) 3219 { 3220 fprintf(stderr, "Microblaze setup_rt_frame: not implemented\n"); 3221 } 3222 3223 long do_sigreturn(CPUState *env) 3224 { 3225 struct target_signal_frame *frame; 3226 abi_ulong frame_addr; 3227 target_sigset_t target_set; 3228 sigset_t set; 3229 int i; 3230 3231 frame_addr = env->regs[R_SP]; 3232 /* Make sure the guest isn't playing games. */ 3233 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1)) 3234 goto badframe; 3235 3236 /* Restore blocked signals */ 3237 if (__get_user(target_set.sig[0], &frame->sc.oldmask)) 3238 goto badframe; 3239 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 3240 if (__get_user(target_set.sig[i], &frame->extramask[i - 1])) 3241 goto badframe; 3242 } 3243 target_to_host_sigset_internal(&set, &target_set); 3244 sigprocmask(SIG_SETMASK, &set, NULL); 3245 3246 restore_sigcontext(&frame->sc, env); 3247 /* We got here through a sigreturn syscall, our path back is via an 3248 rtb insn so setup r14 for that. */ 3249 env->regs[14] = env->sregs[SR_PC]; 3250 3251 unlock_user_struct(frame, frame_addr, 0); 3252 return env->regs[10]; 3253 badframe: 3254 unlock_user_struct(frame, frame_addr, 0); 3255 force_sig(TARGET_SIGSEGV); 3256 } 3257 3258 long do_rt_sigreturn(CPUState *env) 3259 { 3260 fprintf(stderr, "Microblaze do_rt_sigreturn: not implemented\n"); 3261 return -TARGET_ENOSYS; 3262 } 3263 3264 #elif defined(TARGET_CRIS) 3265 3266 struct target_sigcontext { 3267 struct target_pt_regs regs; /* needs to be first */ 3268 uint32_t oldmask; 3269 uint32_t usp; /* usp before stacking this gunk on it */ 3270 }; 3271 3272 /* Signal frames. */ 3273 struct target_signal_frame { 3274 struct target_sigcontext sc; 3275 uint32_t extramask[TARGET_NSIG_WORDS - 1]; 3276 uint8_t retcode[8]; /* Trampoline code. */ 3277 }; 3278 3279 struct rt_signal_frame { 3280 struct siginfo *pinfo; 3281 void *puc; 3282 struct siginfo info; 3283 struct ucontext uc; 3284 uint8_t retcode[8]; /* Trampoline code. */ 3285 }; 3286 3287 static void setup_sigcontext(struct target_sigcontext *sc, CPUState *env) 3288 { 3289 __put_user(env->regs[0], &sc->regs.r0); 3290 __put_user(env->regs[1], &sc->regs.r1); 3291 __put_user(env->regs[2], &sc->regs.r2); 3292 __put_user(env->regs[3], &sc->regs.r3); 3293 __put_user(env->regs[4], &sc->regs.r4); 3294 __put_user(env->regs[5], &sc->regs.r5); 3295 __put_user(env->regs[6], &sc->regs.r6); 3296 __put_user(env->regs[7], &sc->regs.r7); 3297 __put_user(env->regs[8], &sc->regs.r8); 3298 __put_user(env->regs[9], &sc->regs.r9); 3299 __put_user(env->regs[10], &sc->regs.r10); 3300 __put_user(env->regs[11], &sc->regs.r11); 3301 __put_user(env->regs[12], &sc->regs.r12); 3302 __put_user(env->regs[13], &sc->regs.r13); 3303 __put_user(env->regs[14], &sc->usp); 3304 __put_user(env->regs[15], &sc->regs.acr); 3305 __put_user(env->pregs[PR_MOF], &sc->regs.mof); 3306 __put_user(env->pregs[PR_SRP], &sc->regs.srp); 3307 __put_user(env->pc, &sc->regs.erp); 3308 } 3309 3310 static void restore_sigcontext(struct target_sigcontext *sc, CPUState *env) 3311 { 3312 __get_user(env->regs[0], &sc->regs.r0); 3313 __get_user(env->regs[1], &sc->regs.r1); 3314 __get_user(env->regs[2], &sc->regs.r2); 3315 __get_user(env->regs[3], &sc->regs.r3); 3316 __get_user(env->regs[4], &sc->regs.r4); 3317 __get_user(env->regs[5], &sc->regs.r5); 3318 __get_user(env->regs[6], &sc->regs.r6); 3319 __get_user(env->regs[7], &sc->regs.r7); 3320 __get_user(env->regs[8], &sc->regs.r8); 3321 __get_user(env->regs[9], &sc->regs.r9); 3322 __get_user(env->regs[10], &sc->regs.r10); 3323 __get_user(env->regs[11], &sc->regs.r11); 3324 __get_user(env->regs[12], &sc->regs.r12); 3325 __get_user(env->regs[13], &sc->regs.r13); 3326 __get_user(env->regs[14], &sc->usp); 3327 __get_user(env->regs[15], &sc->regs.acr); 3328 __get_user(env->pregs[PR_MOF], &sc->regs.mof); 3329 __get_user(env->pregs[PR_SRP], &sc->regs.srp); 3330 __get_user(env->pc, &sc->regs.erp); 3331 } 3332 3333 static abi_ulong get_sigframe(CPUState *env, int framesize) 3334 { 3335 abi_ulong sp; 3336 /* Align the stack downwards to 4. */ 3337 sp = (env->regs[R_SP] & ~3); 3338 return sp - framesize; 3339 } 3340 3341 static void setup_frame(int sig, struct target_sigaction *ka, 3342 target_sigset_t *set, CPUState *env) 3343 { 3344 struct target_signal_frame *frame; 3345 abi_ulong frame_addr; 3346 int err = 0; 3347 int i; 3348 3349 frame_addr = get_sigframe(env, sizeof *frame); 3350 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 3351 goto badframe; 3352 3353 /* 3354 * The CRIS signal return trampoline. A real linux/CRIS kernel doesn't 3355 * use this trampoline anymore but it sets it up for GDB. 3356 * In QEMU, using the trampoline simplifies things a bit so we use it. 3357 * 3358 * This is movu.w __NR_sigreturn, r9; break 13; 3359 */ 3360 err |= __put_user(0x9c5f, frame->retcode+0); 3361 err |= __put_user(TARGET_NR_sigreturn, 3362 frame->retcode+2); 3363 err |= __put_user(0xe93d, frame->retcode+4); 3364 3365 /* Save the mask. */ 3366 err |= __put_user(set->sig[0], &frame->sc.oldmask); 3367 if (err) 3368 goto badframe; 3369 3370 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 3371 if (__put_user(set->sig[i], &frame->extramask[i - 1])) 3372 goto badframe; 3373 } 3374 3375 setup_sigcontext(&frame->sc, env); 3376 3377 /* Move the stack and setup the arguments for the handler. */ 3378 env->regs[R_SP] = (uint32_t) (unsigned long) frame; 3379 env->regs[10] = sig; 3380 env->pc = (unsigned long) ka->_sa_handler; 3381 /* Link SRP so the guest returns through the trampoline. */ 3382 env->pregs[PR_SRP] = (uint32_t) (unsigned long) &frame->retcode[0]; 3383 3384 unlock_user_struct(frame, frame_addr, 1); 3385 return; 3386 badframe: 3387 unlock_user_struct(frame, frame_addr, 1); 3388 force_sig(TARGET_SIGSEGV); 3389 } 3390 3391 static void setup_rt_frame(int sig, struct target_sigaction *ka, 3392 target_siginfo_t *info, 3393 target_sigset_t *set, CPUState *env) 3394 { 3395 fprintf(stderr, "CRIS setup_rt_frame: not implemented\n"); 3396 } 3397 3398 long do_sigreturn(CPUState *env) 3399 { 3400 struct target_signal_frame *frame; 3401 abi_ulong frame_addr; 3402 target_sigset_t target_set; 3403 sigset_t set; 3404 int i; 3405 3406 frame_addr = env->regs[R_SP]; 3407 /* Make sure the guest isn't playing games. */ 3408 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1)) 3409 goto badframe; 3410 3411 /* Restore blocked signals */ 3412 if (__get_user(target_set.sig[0], &frame->sc.oldmask)) 3413 goto badframe; 3414 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 3415 if (__get_user(target_set.sig[i], &frame->extramask[i - 1])) 3416 goto badframe; 3417 } 3418 target_to_host_sigset_internal(&set, &target_set); 3419 sigprocmask(SIG_SETMASK, &set, NULL); 3420 3421 restore_sigcontext(&frame->sc, env); 3422 unlock_user_struct(frame, frame_addr, 0); 3423 return env->regs[10]; 3424 badframe: 3425 unlock_user_struct(frame, frame_addr, 0); 3426 force_sig(TARGET_SIGSEGV); 3427 } 3428 3429 long do_rt_sigreturn(CPUState *env) 3430 { 3431 fprintf(stderr, "CRIS do_rt_sigreturn: not implemented\n"); 3432 return -TARGET_ENOSYS; 3433 } 3434 3435 #elif defined(TARGET_PPC) && !defined(TARGET_PPC64) 3436 3437 /* FIXME: Many of the structures are defined for both PPC and PPC64, but 3438 the signal handling is different enough that we haven't implemented 3439 support for PPC64 yet. Hence the restriction above. 3440 3441 There are various #if'd blocks for code for TARGET_PPC64. These 3442 blocks should go away so that we can successfully run 32-bit and 3443 64-bit binaries on a QEMU configured for PPC64. */ 3444 3445 /* Size of dummy stack frame allocated when calling signal handler. 3446 See arch/powerpc/include/asm/ptrace.h. */ 3447 #if defined(TARGET_PPC64) 3448 #define SIGNAL_FRAMESIZE 128 3449 #else 3450 #define SIGNAL_FRAMESIZE 64 3451 #endif 3452 3453 /* See arch/powerpc/include/asm/sigcontext.h. */ 3454 struct target_sigcontext { 3455 target_ulong _unused[4]; 3456 int32_t signal; 3457 #if defined(TARGET_PPC64) 3458 int32_t pad0; 3459 #endif 3460 target_ulong handler; 3461 target_ulong oldmask; 3462 target_ulong regs; /* struct pt_regs __user * */ 3463 /* TODO: PPC64 includes extra bits here. */ 3464 }; 3465 3466 /* Indices for target_mcontext.mc_gregs, below. 3467 See arch/powerpc/include/asm/ptrace.h for details. */ 3468 enum { 3469 TARGET_PT_R0 = 0, 3470 TARGET_PT_R1 = 1, 3471 TARGET_PT_R2 = 2, 3472 TARGET_PT_R3 = 3, 3473 TARGET_PT_R4 = 4, 3474 TARGET_PT_R5 = 5, 3475 TARGET_PT_R6 = 6, 3476 TARGET_PT_R7 = 7, 3477 TARGET_PT_R8 = 8, 3478 TARGET_PT_R9 = 9, 3479 TARGET_PT_R10 = 10, 3480 TARGET_PT_R11 = 11, 3481 TARGET_PT_R12 = 12, 3482 TARGET_PT_R13 = 13, 3483 TARGET_PT_R14 = 14, 3484 TARGET_PT_R15 = 15, 3485 TARGET_PT_R16 = 16, 3486 TARGET_PT_R17 = 17, 3487 TARGET_PT_R18 = 18, 3488 TARGET_PT_R19 = 19, 3489 TARGET_PT_R20 = 20, 3490 TARGET_PT_R21 = 21, 3491 TARGET_PT_R22 = 22, 3492 TARGET_PT_R23 = 23, 3493 TARGET_PT_R24 = 24, 3494 TARGET_PT_R25 = 25, 3495 TARGET_PT_R26 = 26, 3496 TARGET_PT_R27 = 27, 3497 TARGET_PT_R28 = 28, 3498 TARGET_PT_R29 = 29, 3499 TARGET_PT_R30 = 30, 3500 TARGET_PT_R31 = 31, 3501 TARGET_PT_NIP = 32, 3502 TARGET_PT_MSR = 33, 3503 TARGET_PT_ORIG_R3 = 34, 3504 TARGET_PT_CTR = 35, 3505 TARGET_PT_LNK = 36, 3506 TARGET_PT_XER = 37, 3507 TARGET_PT_CCR = 38, 3508 /* Yes, there are two registers with #39. One is 64-bit only. */ 3509 TARGET_PT_MQ = 39, 3510 TARGET_PT_SOFTE = 39, 3511 TARGET_PT_TRAP = 40, 3512 TARGET_PT_DAR = 41, 3513 TARGET_PT_DSISR = 42, 3514 TARGET_PT_RESULT = 43, 3515 TARGET_PT_REGS_COUNT = 44 3516 }; 3517 3518 /* See arch/powerpc/include/asm/ucontext.h. Only used for 32-bit PPC; 3519 on 64-bit PPC, sigcontext and mcontext are one and the same. */ 3520 struct target_mcontext { 3521 target_ulong mc_gregs[48]; 3522 /* Includes fpscr. */ 3523 uint64_t mc_fregs[33]; 3524 target_ulong mc_pad[2]; 3525 /* We need to handle Altivec and SPE at the same time, which no 3526 kernel needs to do. Fortunately, the kernel defines this bit to 3527 be Altivec-register-large all the time, rather than trying to 3528 twiddle it based on the specific platform. */ 3529 union { 3530 /* SPE vector registers. One extra for SPEFSCR. */ 3531 uint32_t spe[33]; 3532 /* Altivec vector registers. The packing of VSCR and VRSAVE 3533 varies depending on whether we're PPC64 or not: PPC64 splits 3534 them apart; PPC32 stuffs them together. */ 3535 #if defined(TARGET_PPC64) 3536 #define NVRREG 34 3537 #else 3538 #define NVRREG 33 3539 #endif 3540 ppc_avr_t altivec[NVRREG]; 3541 #undef NVRREG 3542 } mc_vregs __attribute__((__aligned__(16))); 3543 }; 3544 3545 struct target_ucontext { 3546 target_ulong uc_flags; 3547 target_ulong uc_link; /* struct ucontext __user * */ 3548 struct target_sigaltstack uc_stack; 3549 #if !defined(TARGET_PPC64) 3550 int32_t uc_pad[7]; 3551 target_ulong uc_regs; /* struct mcontext __user * 3552 points to uc_mcontext field */ 3553 #endif 3554 target_sigset_t uc_sigmask; 3555 #if defined(TARGET_PPC64) 3556 target_sigset_t unused[15]; /* Allow for uc_sigmask growth */ 3557 struct target_sigcontext uc_mcontext; 3558 #else 3559 int32_t uc_maskext[30]; 3560 int32_t uc_pad2[3]; 3561 struct target_mcontext uc_mcontext; 3562 #endif 3563 }; 3564 3565 /* See arch/powerpc/kernel/signal_32.c. */ 3566 struct target_sigframe { 3567 struct target_sigcontext sctx; 3568 struct target_mcontext mctx; 3569 int32_t abigap[56]; 3570 }; 3571 3572 struct target_rt_sigframe { 3573 struct target_siginfo info; 3574 struct target_ucontext uc; 3575 int32_t abigap[56]; 3576 }; 3577 3578 /* We use the mc_pad field for the signal return trampoline. */ 3579 #define tramp mc_pad 3580 3581 /* See arch/powerpc/kernel/signal.c. */ 3582 static target_ulong get_sigframe(struct target_sigaction *ka, 3583 CPUState *env, 3584 int frame_size) 3585 { 3586 target_ulong oldsp, newsp; 3587 3588 oldsp = env->gpr[1]; 3589 3590 if ((ka->sa_flags & TARGET_SA_ONSTACK) && 3591 (sas_ss_flags(oldsp))) { 3592 oldsp = (target_sigaltstack_used.ss_sp 3593 + target_sigaltstack_used.ss_size); 3594 } 3595 3596 newsp = (oldsp - frame_size) & ~0xFUL; 3597 3598 return newsp; 3599 } 3600 3601 static int save_user_regs(CPUState *env, struct target_mcontext *frame, 3602 int sigret) 3603 { 3604 target_ulong msr = env->msr; 3605 int i; 3606 target_ulong ccr = 0; 3607 3608 /* In general, the kernel attempts to be intelligent about what it 3609 needs to save for Altivec/FP/SPE registers. We don't care that 3610 much, so we just go ahead and save everything. */ 3611 3612 /* Save general registers. */ 3613 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) { 3614 if (__put_user(env->gpr[i], &frame->mc_gregs[i])) { 3615 return 1; 3616 } 3617 } 3618 if (__put_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP]) 3619 || __put_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR]) 3620 || __put_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK]) 3621 || __put_user(env->xer, &frame->mc_gregs[TARGET_PT_XER])) 3622 return 1; 3623 3624 for (i = 0; i < ARRAY_SIZE(env->crf); i++) { 3625 ccr |= env->crf[i] << (32 - ((i + 1) * 4)); 3626 } 3627 if (__put_user(ccr, &frame->mc_gregs[TARGET_PT_CCR])) 3628 return 1; 3629 3630 /* Save Altivec registers if necessary. */ 3631 if (env->insns_flags & PPC_ALTIVEC) { 3632 for (i = 0; i < ARRAY_SIZE(env->avr); i++) { 3633 ppc_avr_t *avr = &env->avr[i]; 3634 ppc_avr_t *vreg = &frame->mc_vregs.altivec[i]; 3635 3636 if (__put_user(avr->u64[0], &vreg->u64[0]) || 3637 __put_user(avr->u64[1], &vreg->u64[1])) { 3638 return 1; 3639 } 3640 } 3641 /* Set MSR_VR in the saved MSR value to indicate that 3642 frame->mc_vregs contains valid data. */ 3643 msr |= MSR_VR; 3644 if (__put_user((uint32_t)env->spr[SPR_VRSAVE], 3645 &frame->mc_vregs.altivec[32].u32[3])) 3646 return 1; 3647 } 3648 3649 /* Save floating point registers. */ 3650 if (env->insns_flags & PPC_FLOAT) { 3651 for (i = 0; i < ARRAY_SIZE(env->fpr); i++) { 3652 if (__put_user(env->fpr[i], &frame->mc_fregs[i])) { 3653 return 1; 3654 } 3655 } 3656 if (__put_user((uint64_t) env->fpscr, &frame->mc_fregs[32])) 3657 return 1; 3658 } 3659 3660 /* Save SPE registers. The kernel only saves the high half. */ 3661 if (env->insns_flags & PPC_SPE) { 3662 #if defined(TARGET_PPC64) 3663 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) { 3664 if (__put_user(env->gpr[i] >> 32, &frame->mc_vregs.spe[i])) { 3665 return 1; 3666 } 3667 } 3668 #else 3669 for (i = 0; i < ARRAY_SIZE(env->gprh); i++) { 3670 if (__put_user(env->gprh[i], &frame->mc_vregs.spe[i])) { 3671 return 1; 3672 } 3673 } 3674 #endif 3675 /* Set MSR_SPE in the saved MSR value to indicate that 3676 frame->mc_vregs contains valid data. */ 3677 msr |= MSR_SPE; 3678 if (__put_user(env->spe_fscr, &frame->mc_vregs.spe[32])) 3679 return 1; 3680 } 3681 3682 /* Store MSR. */ 3683 if (__put_user(msr, &frame->mc_gregs[TARGET_PT_MSR])) 3684 return 1; 3685 3686 /* Set up the sigreturn trampoline: li r0,sigret; sc. */ 3687 if (sigret) { 3688 if (__put_user(0x38000000UL | sigret, &frame->tramp[0]) || 3689 __put_user(0x44000002UL, &frame->tramp[1])) { 3690 return 1; 3691 } 3692 } 3693 3694 return 0; 3695 } 3696 3697 static int restore_user_regs(CPUState *env, 3698 struct target_mcontext *frame, int sig) 3699 { 3700 target_ulong save_r2 = 0; 3701 target_ulong msr; 3702 target_ulong ccr; 3703 3704 int i; 3705 3706 if (!sig) { 3707 save_r2 = env->gpr[2]; 3708 } 3709 3710 /* Restore general registers. */ 3711 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) { 3712 if (__get_user(env->gpr[i], &frame->mc_gregs[i])) { 3713 return 1; 3714 } 3715 } 3716 if (__get_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP]) 3717 || __get_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR]) 3718 || __get_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK]) 3719 || __get_user(env->xer, &frame->mc_gregs[TARGET_PT_XER])) 3720 return 1; 3721 if (__get_user(ccr, &frame->mc_gregs[TARGET_PT_CCR])) 3722 return 1; 3723 3724 for (i = 0; i < ARRAY_SIZE(env->crf); i++) { 3725 env->crf[i] = (ccr >> (32 - ((i + 1) * 4))) & 0xf; 3726 } 3727 3728 if (!sig) { 3729 env->gpr[2] = save_r2; 3730 } 3731 /* Restore MSR. */ 3732 if (__get_user(msr, &frame->mc_gregs[TARGET_PT_MSR])) 3733 return 1; 3734 3735 /* If doing signal return, restore the previous little-endian mode. */ 3736 if (sig) 3737 env->msr = (env->msr & ~MSR_LE) | (msr & MSR_LE); 3738 3739 /* Restore Altivec registers if necessary. */ 3740 if (env->insns_flags & PPC_ALTIVEC) { 3741 for (i = 0; i < ARRAY_SIZE(env->avr); i++) { 3742 ppc_avr_t *avr = &env->avr[i]; 3743 ppc_avr_t *vreg = &frame->mc_vregs.altivec[i]; 3744 3745 if (__get_user(avr->u64[0], &vreg->u64[0]) || 3746 __get_user(avr->u64[1], &vreg->u64[1])) { 3747 return 1; 3748 } 3749 } 3750 /* Set MSR_VEC in the saved MSR value to indicate that 3751 frame->mc_vregs contains valid data. */ 3752 if (__get_user(env->spr[SPR_VRSAVE], 3753 (target_ulong *)(&frame->mc_vregs.altivec[32].u32[3]))) 3754 return 1; 3755 } 3756 3757 /* Restore floating point registers. */ 3758 if (env->insns_flags & PPC_FLOAT) { 3759 uint64_t fpscr; 3760 for (i = 0; i < ARRAY_SIZE(env->fpr); i++) { 3761 if (__get_user(env->fpr[i], &frame->mc_fregs[i])) { 3762 return 1; 3763 } 3764 } 3765 if (__get_user(fpscr, &frame->mc_fregs[32])) 3766 return 1; 3767 env->fpscr = (uint32_t) fpscr; 3768 } 3769 3770 /* Save SPE registers. The kernel only saves the high half. */ 3771 if (env->insns_flags & PPC_SPE) { 3772 #if defined(TARGET_PPC64) 3773 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) { 3774 uint32_t hi; 3775 3776 if (__get_user(hi, &frame->mc_vregs.spe[i])) { 3777 return 1; 3778 } 3779 env->gpr[i] = ((uint64_t)hi << 32) | ((uint32_t) env->gpr[i]); 3780 } 3781 #else 3782 for (i = 0; i < ARRAY_SIZE(env->gprh); i++) { 3783 if (__get_user(env->gprh[i], &frame->mc_vregs.spe[i])) { 3784 return 1; 3785 } 3786 } 3787 #endif 3788 if (__get_user(env->spe_fscr, &frame->mc_vregs.spe[32])) 3789 return 1; 3790 } 3791 3792 return 0; 3793 } 3794 3795 static void setup_frame(int sig, struct target_sigaction *ka, 3796 target_sigset_t *set, CPUState *env) 3797 { 3798 struct target_sigframe *frame; 3799 struct target_sigcontext *sc; 3800 target_ulong frame_addr, newsp; 3801 int err = 0; 3802 int signal; 3803 3804 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 3805 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1)) 3806 goto sigsegv; 3807 sc = &frame->sctx; 3808 3809 signal = current_exec_domain_sig(sig); 3810 3811 err |= __put_user(h2g(ka->_sa_handler), &sc->handler); 3812 err |= __put_user(set->sig[0], &sc->oldmask); 3813 #if defined(TARGET_PPC64) 3814 err |= __put_user(set->sig[0] >> 32, &sc->_unused[3]); 3815 #else 3816 err |= __put_user(set->sig[1], &sc->_unused[3]); 3817 #endif 3818 err |= __put_user(h2g(&frame->mctx), &sc->regs); 3819 err |= __put_user(sig, &sc->signal); 3820 3821 /* Save user regs. */ 3822 err |= save_user_regs(env, &frame->mctx, TARGET_NR_sigreturn); 3823 3824 /* The kernel checks for the presence of a VDSO here. We don't 3825 emulate a vdso, so use a sigreturn system call. */ 3826 env->lr = (target_ulong) h2g(frame->mctx.tramp); 3827 3828 /* Turn off all fp exceptions. */ 3829 env->fpscr = 0; 3830 3831 /* Create a stack frame for the caller of the handler. */ 3832 newsp = frame_addr - SIGNAL_FRAMESIZE; 3833 err |= __put_user(env->gpr[1], (target_ulong *)(uintptr_t) newsp); 3834 3835 if (err) 3836 goto sigsegv; 3837 3838 /* Set up registers for signal handler. */ 3839 env->gpr[1] = newsp; 3840 env->gpr[3] = signal; 3841 env->gpr[4] = (target_ulong) h2g(sc); 3842 env->nip = (target_ulong) ka->_sa_handler; 3843 /* Signal handlers are entered in big-endian mode. */ 3844 env->msr &= ~MSR_LE; 3845 3846 unlock_user_struct(frame, frame_addr, 1); 3847 return; 3848 3849 sigsegv: 3850 unlock_user_struct(frame, frame_addr, 1); 3851 if (logfile) 3852 fprintf (logfile, "segfaulting from setup_frame\n"); 3853 force_sig(SIGSEGV); 3854 } 3855 3856 static void setup_rt_frame(int sig, struct target_sigaction *ka, 3857 target_siginfo_t *info, 3858 target_sigset_t *set, CPUState *env) 3859 { 3860 struct target_rt_sigframe *rt_sf; 3861 struct target_mcontext *frame; 3862 target_ulong rt_sf_addr, newsp = 0; 3863 int i, err = 0; 3864 int signal; 3865 3866 rt_sf_addr = get_sigframe(ka, env, sizeof(*rt_sf)); 3867 if (!lock_user_struct(VERIFY_WRITE, rt_sf, rt_sf_addr, 1)) 3868 goto sigsegv; 3869 3870 signal = current_exec_domain_sig(sig); 3871 3872 err |= copy_siginfo_to_user(&rt_sf->info, info); 3873 3874 err |= __put_user(0, &rt_sf->uc.uc_flags); 3875 err |= __put_user(0, &rt_sf->uc.uc_link); 3876 err |= __put_user((target_ulong)target_sigaltstack_used.ss_sp, 3877 &rt_sf->uc.uc_stack.ss_sp); 3878 err |= __put_user(sas_ss_flags(env->gpr[1]), 3879 &rt_sf->uc.uc_stack.ss_flags); 3880 err |= __put_user(target_sigaltstack_used.ss_size, 3881 &rt_sf->uc.uc_stack.ss_size); 3882 err |= __put_user(h2g (&rt_sf->uc.uc_mcontext), 3883 &rt_sf->uc.uc_regs); 3884 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 3885 err |= __put_user(set->sig[i], &rt_sf->uc.uc_sigmask.sig[i]); 3886 } 3887 3888 frame = &rt_sf->uc.uc_mcontext; 3889 err |= save_user_regs(env, frame, TARGET_NR_rt_sigreturn); 3890 3891 /* The kernel checks for the presence of a VDSO here. We don't 3892 emulate a vdso, so use a sigreturn system call. */ 3893 env->lr = (target_ulong) h2g(frame->tramp); 3894 3895 /* Turn off all fp exceptions. */ 3896 env->fpscr = 0; 3897 3898 /* Create a stack frame for the caller of the handler. */ 3899 newsp = rt_sf_addr - (SIGNAL_FRAMESIZE + 16); 3900 err |= __put_user(env->gpr[1], (target_ulong *)(uintptr_t) newsp); 3901 3902 if (err) 3903 goto sigsegv; 3904 3905 /* Set up registers for signal handler. */ 3906 env->gpr[1] = newsp; 3907 env->gpr[3] = (target_ulong) signal; 3908 env->gpr[4] = (target_ulong) h2g(&rt_sf->info); 3909 env->gpr[5] = (target_ulong) h2g(&rt_sf->uc); 3910 env->gpr[6] = (target_ulong) h2g(rt_sf); 3911 env->nip = (target_ulong) ka->_sa_handler; 3912 /* Signal handlers are entered in big-endian mode. */ 3913 env->msr &= ~MSR_LE; 3914 3915 unlock_user_struct(rt_sf, rt_sf_addr, 1); 3916 return; 3917 3918 sigsegv: 3919 unlock_user_struct(rt_sf, rt_sf_addr, 1); 3920 if (logfile) 3921 fprintf (logfile, "segfaulting from setup_rt_frame\n"); 3922 force_sig(SIGSEGV); 3923 3924 } 3925 3926 long do_sigreturn(CPUState *env) 3927 { 3928 struct target_sigcontext *sc = NULL; 3929 struct target_mcontext *sr = NULL; 3930 target_ulong sr_addr, sc_addr; 3931 sigset_t blocked; 3932 target_sigset_t set; 3933 3934 sc_addr = env->gpr[1] + SIGNAL_FRAMESIZE; 3935 if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1)) 3936 goto sigsegv; 3937 3938 #if defined(TARGET_PPC64) 3939 set.sig[0] = sc->oldmask + ((long)(sc->_unused[3]) << 32); 3940 #else 3941 if(__get_user(set.sig[0], &sc->oldmask) || 3942 __get_user(set.sig[1], &sc->_unused[3])) 3943 goto sigsegv; 3944 #endif 3945 target_to_host_sigset_internal(&blocked, &set); 3946 sigprocmask(SIG_SETMASK, &blocked, NULL); 3947 3948 if (__get_user(sr_addr, &sc->regs)) 3949 goto sigsegv; 3950 if (!lock_user_struct(VERIFY_READ, sr, sr_addr, 1)) 3951 goto sigsegv; 3952 if (restore_user_regs(env, sr, 1)) 3953 goto sigsegv; 3954 3955 unlock_user_struct(sr, sr_addr, 1); 3956 unlock_user_struct(sc, sc_addr, 1); 3957 return -TARGET_QEMU_ESIGRETURN; 3958 3959 sigsegv: 3960 unlock_user_struct(sr, sr_addr, 1); 3961 unlock_user_struct(sc, sc_addr, 1); 3962 if (logfile) 3963 fprintf (logfile, "segfaulting from do_sigreturn\n"); 3964 force_sig(SIGSEGV); 3965 return 0; 3966 } 3967 3968 /* See arch/powerpc/kernel/signal_32.c. */ 3969 static int do_setcontext(struct target_ucontext *ucp, CPUState *env, int sig) 3970 { 3971 struct target_mcontext *mcp; 3972 target_ulong mcp_addr; 3973 sigset_t blocked; 3974 target_sigset_t set; 3975 3976 if (copy_from_user(&set, h2g(ucp) + offsetof(struct target_ucontext, uc_sigmask), 3977 sizeof (set))) 3978 return 1; 3979 3980 #if defined(TARGET_PPC64) 3981 fprintf (stderr, "do_setcontext: not implemented\n"); 3982 return 0; 3983 #else 3984 if (__get_user(mcp_addr, &ucp->uc_regs)) 3985 return 1; 3986 3987 if (!lock_user_struct(VERIFY_READ, mcp, mcp_addr, 1)) 3988 return 1; 3989 3990 target_to_host_sigset_internal(&blocked, &set); 3991 sigprocmask(SIG_SETMASK, &blocked, NULL); 3992 if (restore_user_regs(env, mcp, sig)) 3993 goto sigsegv; 3994 3995 unlock_user_struct(mcp, mcp_addr, 1); 3996 return 0; 3997 3998 sigsegv: 3999 unlock_user_struct(mcp, mcp_addr, 1); 4000 return 1; 4001 #endif 4002 } 4003 4004 long do_rt_sigreturn(CPUState *env) 4005 { 4006 struct target_rt_sigframe *rt_sf = NULL; 4007 target_ulong rt_sf_addr; 4008 4009 rt_sf_addr = env->gpr[1] + SIGNAL_FRAMESIZE + 16; 4010 if (!lock_user_struct(VERIFY_READ, rt_sf, rt_sf_addr, 1)) 4011 goto sigsegv; 4012 4013 if (do_setcontext(&rt_sf->uc, env, 1)) 4014 goto sigsegv; 4015 4016 do_sigaltstack(rt_sf_addr 4017 + offsetof(struct target_rt_sigframe, uc.uc_stack), 4018 0, env->gpr[1]); 4019 4020 unlock_user_struct(rt_sf, rt_sf_addr, 1); 4021 return -TARGET_QEMU_ESIGRETURN; 4022 4023 sigsegv: 4024 unlock_user_struct(rt_sf, rt_sf_addr, 1); 4025 if (logfile) 4026 fprintf (logfile, "segfaulting from do_rt_sigreturn\n"); 4027 force_sig(SIGSEGV); 4028 return 0; 4029 } 4030 4031 #else 4032 4033 static void setup_frame(int sig, struct target_sigaction *ka, 4034 target_sigset_t *set, CPUState *env) 4035 { 4036 fprintf(stderr, "setup_frame: not implemented\n"); 4037 } 4038 4039 static void setup_rt_frame(int sig, struct target_sigaction *ka, 4040 target_siginfo_t *info, 4041 target_sigset_t *set, CPUState *env) 4042 { 4043 fprintf(stderr, "setup_rt_frame: not implemented\n"); 4044 } 4045 4046 long do_sigreturn(CPUState *env) 4047 { 4048 fprintf(stderr, "do_sigreturn: not implemented\n"); 4049 return -TARGET_ENOSYS; 4050 } 4051 4052 long do_rt_sigreturn(CPUState *env) 4053 { 4054 fprintf(stderr, "do_rt_sigreturn: not implemented\n"); 4055 return -TARGET_ENOSYS; 4056 } 4057 4058 #endif 4059 4060 void process_pending_signals(CPUState *cpu_env) 4061 { 4062 int sig; 4063 abi_ulong handler; 4064 sigset_t set, old_set; 4065 target_sigset_t target_old_set; 4066 struct emulated_sigtable *k; 4067 struct target_sigaction *sa; 4068 struct sigqueue *q; 4069 TaskState *ts = cpu_env->opaque; 4070 4071 if (!ts->signal_pending) 4072 return; 4073 4074 /* FIXME: This is not threadsafe. */ 4075 k = ts->sigtab; 4076 for(sig = 1; sig <= TARGET_NSIG; sig++) { 4077 if (k->pending) 4078 goto handle_signal; 4079 k++; 4080 } 4081 /* if no signal is pending, just return */ 4082 ts->signal_pending = 0; 4083 return; 4084 4085 handle_signal: 4086 #ifdef DEBUG_SIGNAL 4087 fprintf(stderr, "qemu: process signal %d\n", sig); 4088 #endif 4089 /* dequeue signal */ 4090 q = k->first; 4091 k->first = q->next; 4092 if (!k->first) 4093 k->pending = 0; 4094 4095 sig = gdb_handlesig (cpu_env, sig); 4096 if (!sig) { 4097 sa = NULL; 4098 handler = TARGET_SIG_IGN; 4099 } else { 4100 sa = &sigact_table[sig - 1]; 4101 handler = sa->_sa_handler; 4102 } 4103 4104 if (handler == TARGET_SIG_DFL) { 4105 /* default handler : ignore some signal. The other are job control or fatal */ 4106 if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) { 4107 kill(getpid(),SIGSTOP); 4108 } else if (sig != TARGET_SIGCHLD && 4109 sig != TARGET_SIGURG && 4110 sig != TARGET_SIGWINCH && 4111 sig != TARGET_SIGCONT) { 4112 force_sig(sig); 4113 } 4114 } else if (handler == TARGET_SIG_IGN) { 4115 /* ignore sig */ 4116 } else if (handler == TARGET_SIG_ERR) { 4117 force_sig(sig); 4118 } else { 4119 /* compute the blocked signals during the handler execution */ 4120 target_to_host_sigset(&set, &sa->sa_mask); 4121 /* SA_NODEFER indicates that the current signal should not be 4122 blocked during the handler */ 4123 if (!(sa->sa_flags & TARGET_SA_NODEFER)) 4124 sigaddset(&set, target_to_host_signal(sig)); 4125 4126 /* block signals in the handler using Linux */ 4127 sigprocmask(SIG_BLOCK, &set, &old_set); 4128 /* save the previous blocked signal state to restore it at the 4129 end of the signal execution (see do_sigreturn) */ 4130 host_to_target_sigset_internal(&target_old_set, &old_set); 4131 4132 /* if the CPU is in VM86 mode, we restore the 32 bit values */ 4133 #if defined(TARGET_I386) && !defined(TARGET_X86_64) 4134 { 4135 CPUX86State *env = cpu_env; 4136 if (env->eflags & VM_MASK) 4137 save_v86_state(env); 4138 } 4139 #endif 4140 /* prepare the stack frame of the virtual CPU */ 4141 if (sa->sa_flags & TARGET_SA_SIGINFO) 4142 setup_rt_frame(sig, sa, &q->info, &target_old_set, cpu_env); 4143 else 4144 setup_frame(sig, sa, &target_old_set, cpu_env); 4145 if (sa->sa_flags & TARGET_SA_RESETHAND) 4146 sa->_sa_handler = TARGET_SIG_DFL; 4147 } 4148 if (q != &k->info) 4149 free_sigqueue(cpu_env, q); 4150 } 4151