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, see <http://www.gnu.org/licenses/>. 18 */ 19 #include <stdlib.h> 20 #include <stdio.h> 21 #include <string.h> 22 #include <stdarg.h> 23 #include <unistd.h> 24 #include <signal.h> 25 #include <errno.h> 26 #include <assert.h> 27 #include <sys/ucontext.h> 28 #include <sys/resource.h> 29 30 #include "qemu.h" 31 #include "qemu-common.h" 32 #include "target_signal.h" 33 34 //#define DEBUG_SIGNAL 35 36 static struct target_sigaltstack target_sigaltstack_used = { 37 .ss_sp = 0, 38 .ss_size = 0, 39 .ss_flags = TARGET_SS_DISABLE, 40 }; 41 42 static struct target_sigaction sigact_table[TARGET_NSIG]; 43 44 static void host_signal_handler(int host_signum, siginfo_t *info, 45 void *puc); 46 47 static uint8_t host_to_target_signal_table[_NSIG] = { 48 [SIGHUP] = TARGET_SIGHUP, 49 [SIGINT] = TARGET_SIGINT, 50 [SIGQUIT] = TARGET_SIGQUIT, 51 [SIGILL] = TARGET_SIGILL, 52 [SIGTRAP] = TARGET_SIGTRAP, 53 [SIGABRT] = TARGET_SIGABRT, 54 /* [SIGIOT] = TARGET_SIGIOT,*/ 55 [SIGBUS] = TARGET_SIGBUS, 56 [SIGFPE] = TARGET_SIGFPE, 57 [SIGKILL] = TARGET_SIGKILL, 58 [SIGUSR1] = TARGET_SIGUSR1, 59 [SIGSEGV] = TARGET_SIGSEGV, 60 [SIGUSR2] = TARGET_SIGUSR2, 61 [SIGPIPE] = TARGET_SIGPIPE, 62 [SIGALRM] = TARGET_SIGALRM, 63 [SIGTERM] = TARGET_SIGTERM, 64 #ifdef SIGSTKFLT 65 [SIGSTKFLT] = TARGET_SIGSTKFLT, 66 #endif 67 [SIGCHLD] = TARGET_SIGCHLD, 68 [SIGCONT] = TARGET_SIGCONT, 69 [SIGSTOP] = TARGET_SIGSTOP, 70 [SIGTSTP] = TARGET_SIGTSTP, 71 [SIGTTIN] = TARGET_SIGTTIN, 72 [SIGTTOU] = TARGET_SIGTTOU, 73 [SIGURG] = TARGET_SIGURG, 74 [SIGXCPU] = TARGET_SIGXCPU, 75 [SIGXFSZ] = TARGET_SIGXFSZ, 76 [SIGVTALRM] = TARGET_SIGVTALRM, 77 [SIGPROF] = TARGET_SIGPROF, 78 [SIGWINCH] = TARGET_SIGWINCH, 79 [SIGIO] = TARGET_SIGIO, 80 [SIGPWR] = TARGET_SIGPWR, 81 [SIGSYS] = TARGET_SIGSYS, 82 /* next signals stay the same */ 83 /* Nasty hack: Reverse SIGRTMIN and SIGRTMAX to avoid overlap with 84 host libpthread signals. This assumes noone actually uses SIGRTMAX :-/ 85 To fix this properly we need to do manual signal delivery multiplexed 86 over a single host signal. */ 87 [__SIGRTMIN] = __SIGRTMAX, 88 [__SIGRTMAX] = __SIGRTMIN, 89 }; 90 static uint8_t target_to_host_signal_table[_NSIG]; 91 92 static inline int on_sig_stack(unsigned long sp) 93 { 94 return (sp - target_sigaltstack_used.ss_sp 95 < target_sigaltstack_used.ss_size); 96 } 97 98 static inline int sas_ss_flags(unsigned long sp) 99 { 100 return (target_sigaltstack_used.ss_size == 0 ? SS_DISABLE 101 : on_sig_stack(sp) ? SS_ONSTACK : 0); 102 } 103 104 int host_to_target_signal(int sig) 105 { 106 if (sig >= _NSIG) 107 return sig; 108 return host_to_target_signal_table[sig]; 109 } 110 111 int target_to_host_signal(int sig) 112 { 113 if (sig >= _NSIG) 114 return sig; 115 return target_to_host_signal_table[sig]; 116 } 117 118 static inline void target_sigemptyset(target_sigset_t *set) 119 { 120 memset(set, 0, sizeof(*set)); 121 } 122 123 static inline void target_sigaddset(target_sigset_t *set, int signum) 124 { 125 signum--; 126 abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW); 127 set->sig[signum / TARGET_NSIG_BPW] |= mask; 128 } 129 130 static inline int target_sigismember(const target_sigset_t *set, int signum) 131 { 132 signum--; 133 abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW); 134 return ((set->sig[signum / TARGET_NSIG_BPW] & mask) != 0); 135 } 136 137 static void host_to_target_sigset_internal(target_sigset_t *d, 138 const sigset_t *s) 139 { 140 int i; 141 target_sigemptyset(d); 142 for (i = 1; i <= TARGET_NSIG; i++) { 143 if (sigismember(s, i)) { 144 target_sigaddset(d, host_to_target_signal(i)); 145 } 146 } 147 } 148 149 void host_to_target_sigset(target_sigset_t *d, const sigset_t *s) 150 { 151 target_sigset_t d1; 152 int i; 153 154 host_to_target_sigset_internal(&d1, s); 155 for(i = 0;i < TARGET_NSIG_WORDS; i++) 156 d->sig[i] = tswapl(d1.sig[i]); 157 } 158 159 static void target_to_host_sigset_internal(sigset_t *d, 160 const target_sigset_t *s) 161 { 162 int i; 163 sigemptyset(d); 164 for (i = 1; i <= TARGET_NSIG; i++) { 165 if (target_sigismember(s, i)) { 166 sigaddset(d, target_to_host_signal(i)); 167 } 168 } 169 } 170 171 void target_to_host_sigset(sigset_t *d, const target_sigset_t *s) 172 { 173 target_sigset_t s1; 174 int i; 175 176 for(i = 0;i < TARGET_NSIG_WORDS; i++) 177 s1.sig[i] = tswapl(s->sig[i]); 178 target_to_host_sigset_internal(d, &s1); 179 } 180 181 void host_to_target_old_sigset(abi_ulong *old_sigset, 182 const sigset_t *sigset) 183 { 184 target_sigset_t d; 185 host_to_target_sigset(&d, sigset); 186 *old_sigset = d.sig[0]; 187 } 188 189 void target_to_host_old_sigset(sigset_t *sigset, 190 const abi_ulong *old_sigset) 191 { 192 target_sigset_t d; 193 int i; 194 195 d.sig[0] = *old_sigset; 196 for(i = 1;i < TARGET_NSIG_WORDS; i++) 197 d.sig[i] = 0; 198 target_to_host_sigset(sigset, &d); 199 } 200 201 /* siginfo conversion */ 202 203 static inline void host_to_target_siginfo_noswap(target_siginfo_t *tinfo, 204 const siginfo_t *info) 205 { 206 int sig; 207 sig = host_to_target_signal(info->si_signo); 208 tinfo->si_signo = sig; 209 tinfo->si_errno = 0; 210 tinfo->si_code = info->si_code; 211 if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV || 212 sig == SIGBUS || sig == SIGTRAP) { 213 /* should never come here, but who knows. The information for 214 the target is irrelevant */ 215 tinfo->_sifields._sigfault._addr = 0; 216 } else if (sig == SIGIO) { 217 tinfo->_sifields._sigpoll._fd = info->si_fd; 218 } else if (sig >= TARGET_SIGRTMIN) { 219 tinfo->_sifields._rt._pid = info->si_pid; 220 tinfo->_sifields._rt._uid = info->si_uid; 221 /* XXX: potential problem if 64 bit */ 222 tinfo->_sifields._rt._sigval.sival_ptr = 223 (abi_ulong)(unsigned long)info->si_value.sival_ptr; 224 } 225 } 226 227 static void tswap_siginfo(target_siginfo_t *tinfo, 228 const target_siginfo_t *info) 229 { 230 int sig; 231 sig = info->si_signo; 232 tinfo->si_signo = tswap32(sig); 233 tinfo->si_errno = tswap32(info->si_errno); 234 tinfo->si_code = tswap32(info->si_code); 235 if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV || 236 sig == SIGBUS || sig == SIGTRAP) { 237 tinfo->_sifields._sigfault._addr = 238 tswapl(info->_sifields._sigfault._addr); 239 } else if (sig == SIGIO) { 240 tinfo->_sifields._sigpoll._fd = tswap32(info->_sifields._sigpoll._fd); 241 } else if (sig >= TARGET_SIGRTMIN) { 242 tinfo->_sifields._rt._pid = tswap32(info->_sifields._rt._pid); 243 tinfo->_sifields._rt._uid = tswap32(info->_sifields._rt._uid); 244 tinfo->_sifields._rt._sigval.sival_ptr = 245 tswapl(info->_sifields._rt._sigval.sival_ptr); 246 } 247 } 248 249 250 void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info) 251 { 252 host_to_target_siginfo_noswap(tinfo, info); 253 tswap_siginfo(tinfo, tinfo); 254 } 255 256 /* XXX: we support only POSIX RT signals are used. */ 257 /* XXX: find a solution for 64 bit (additional malloced data is needed) */ 258 void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo) 259 { 260 info->si_signo = tswap32(tinfo->si_signo); 261 info->si_errno = tswap32(tinfo->si_errno); 262 info->si_code = tswap32(tinfo->si_code); 263 info->si_pid = tswap32(tinfo->_sifields._rt._pid); 264 info->si_uid = tswap32(tinfo->_sifields._rt._uid); 265 info->si_value.sival_ptr = 266 (void *)(long)tswapl(tinfo->_sifields._rt._sigval.sival_ptr); 267 } 268 269 static int fatal_signal (int sig) 270 { 271 switch (sig) { 272 case TARGET_SIGCHLD: 273 case TARGET_SIGURG: 274 case TARGET_SIGWINCH: 275 /* Ignored by default. */ 276 return 0; 277 case TARGET_SIGCONT: 278 case TARGET_SIGSTOP: 279 case TARGET_SIGTSTP: 280 case TARGET_SIGTTIN: 281 case TARGET_SIGTTOU: 282 /* Job control signals. */ 283 return 0; 284 default: 285 return 1; 286 } 287 } 288 289 /* returns 1 if given signal should dump core if not handled */ 290 static int core_dump_signal(int sig) 291 { 292 switch (sig) { 293 case TARGET_SIGABRT: 294 case TARGET_SIGFPE: 295 case TARGET_SIGILL: 296 case TARGET_SIGQUIT: 297 case TARGET_SIGSEGV: 298 case TARGET_SIGTRAP: 299 case TARGET_SIGBUS: 300 return (1); 301 default: 302 return (0); 303 } 304 } 305 306 void signal_init(void) 307 { 308 struct sigaction act; 309 struct sigaction oact; 310 int i, j; 311 int host_sig; 312 313 /* generate signal conversion tables */ 314 for(i = 1; i < _NSIG; i++) { 315 if (host_to_target_signal_table[i] == 0) 316 host_to_target_signal_table[i] = i; 317 } 318 for(i = 1; i < _NSIG; i++) { 319 j = host_to_target_signal_table[i]; 320 target_to_host_signal_table[j] = i; 321 } 322 323 /* set all host signal handlers. ALL signals are blocked during 324 the handlers to serialize them. */ 325 memset(sigact_table, 0, sizeof(sigact_table)); 326 327 sigfillset(&act.sa_mask); 328 act.sa_flags = SA_SIGINFO; 329 act.sa_sigaction = host_signal_handler; 330 for(i = 1; i <= TARGET_NSIG; i++) { 331 host_sig = target_to_host_signal(i); 332 sigaction(host_sig, NULL, &oact); 333 if (oact.sa_sigaction == (void *)SIG_IGN) { 334 sigact_table[i - 1]._sa_handler = TARGET_SIG_IGN; 335 } else if (oact.sa_sigaction == (void *)SIG_DFL) { 336 sigact_table[i - 1]._sa_handler = TARGET_SIG_DFL; 337 } 338 /* If there's already a handler installed then something has 339 gone horribly wrong, so don't even try to handle that case. */ 340 /* Install some handlers for our own use. We need at least 341 SIGSEGV and SIGBUS, to detect exceptions. We can not just 342 trap all signals because it affects syscall interrupt 343 behavior. But do trap all default-fatal signals. */ 344 if (fatal_signal (i)) 345 sigaction(host_sig, &act, NULL); 346 } 347 } 348 349 /* signal queue handling */ 350 351 static inline struct sigqueue *alloc_sigqueue(CPUState *env) 352 { 353 TaskState *ts = env->opaque; 354 struct sigqueue *q = ts->first_free; 355 if (!q) 356 return NULL; 357 ts->first_free = q->next; 358 return q; 359 } 360 361 static inline void free_sigqueue(CPUState *env, struct sigqueue *q) 362 { 363 TaskState *ts = env->opaque; 364 q->next = ts->first_free; 365 ts->first_free = q; 366 } 367 368 /* abort execution with signal */ 369 static void QEMU_NORETURN force_sig(int target_sig) 370 { 371 TaskState *ts = (TaskState *)thread_env->opaque; 372 int host_sig, core_dumped = 0; 373 struct sigaction act; 374 host_sig = target_to_host_signal(target_sig); 375 gdb_signalled(thread_env, target_sig); 376 377 /* dump core if supported by target binary format */ 378 if (core_dump_signal(target_sig) && (ts->bprm->core_dump != NULL)) { 379 stop_all_tasks(); 380 core_dumped = 381 ((*ts->bprm->core_dump)(target_sig, thread_env) == 0); 382 } 383 if (core_dumped) { 384 /* we already dumped the core of target process, we don't want 385 * a coredump of qemu itself */ 386 struct rlimit nodump; 387 getrlimit(RLIMIT_CORE, &nodump); 388 nodump.rlim_cur=0; 389 setrlimit(RLIMIT_CORE, &nodump); 390 (void) fprintf(stderr, "qemu: uncaught target signal %d (%s) - %s\n", 391 target_sig, strsignal(host_sig), "core dumped" ); 392 } 393 394 /* The proper exit code for dieing from an uncaught signal is 395 * -<signal>. The kernel doesn't allow exit() or _exit() to pass 396 * a negative value. To get the proper exit code we need to 397 * actually die from an uncaught signal. Here the default signal 398 * handler is installed, we send ourself a signal and we wait for 399 * it to arrive. */ 400 sigfillset(&act.sa_mask); 401 act.sa_handler = SIG_DFL; 402 sigaction(host_sig, &act, NULL); 403 404 /* For some reason raise(host_sig) doesn't send the signal when 405 * statically linked on x86-64. */ 406 kill(getpid(), host_sig); 407 408 /* Make sure the signal isn't masked (just reuse the mask inside 409 of act) */ 410 sigdelset(&act.sa_mask, host_sig); 411 sigsuspend(&act.sa_mask); 412 413 /* unreachable */ 414 assert(0); 415 abort(); 416 } 417 418 /* queue a signal so that it will be send to the virtual CPU as soon 419 as possible */ 420 int queue_signal(CPUState *env, int sig, target_siginfo_t *info) 421 { 422 TaskState *ts = env->opaque; 423 struct emulated_sigtable *k; 424 struct sigqueue *q, **pq; 425 abi_ulong handler; 426 int queue; 427 428 #if defined(DEBUG_SIGNAL) 429 fprintf(stderr, "queue_signal: sig=%d\n", 430 sig); 431 #endif 432 k = &ts->sigtab[sig - 1]; 433 queue = gdb_queuesig (); 434 handler = sigact_table[sig - 1]._sa_handler; 435 if (!queue && handler == TARGET_SIG_DFL) { 436 if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) { 437 kill(getpid(),SIGSTOP); 438 return 0; 439 } else 440 /* default handler : ignore some signal. The other are fatal */ 441 if (sig != TARGET_SIGCHLD && 442 sig != TARGET_SIGURG && 443 sig != TARGET_SIGWINCH && 444 sig != TARGET_SIGCONT) { 445 force_sig(sig); 446 } else { 447 return 0; /* indicate ignored */ 448 } 449 } else if (!queue && handler == TARGET_SIG_IGN) { 450 /* ignore signal */ 451 return 0; 452 } else if (!queue && handler == TARGET_SIG_ERR) { 453 force_sig(sig); 454 } else { 455 pq = &k->first; 456 if (sig < TARGET_SIGRTMIN) { 457 /* if non real time signal, we queue exactly one signal */ 458 if (!k->pending) 459 q = &k->info; 460 else 461 return 0; 462 } else { 463 if (!k->pending) { 464 /* first signal */ 465 q = &k->info; 466 } else { 467 q = alloc_sigqueue(env); 468 if (!q) 469 return -EAGAIN; 470 while (*pq != NULL) 471 pq = &(*pq)->next; 472 } 473 } 474 *pq = q; 475 q->info = *info; 476 q->next = NULL; 477 k->pending = 1; 478 /* signal that a new signal is pending */ 479 ts->signal_pending = 1; 480 return 1; /* indicates that the signal was queued */ 481 } 482 } 483 484 static void host_signal_handler(int host_signum, siginfo_t *info, 485 void *puc) 486 { 487 int sig; 488 target_siginfo_t tinfo; 489 490 /* the CPU emulator uses some host signals to detect exceptions, 491 we forward to it some signals */ 492 if ((host_signum == SIGSEGV || host_signum == SIGBUS) 493 && info->si_code > 0) { 494 if (cpu_signal_handler(host_signum, info, puc)) 495 return; 496 } 497 498 /* get target signal number */ 499 sig = host_to_target_signal(host_signum); 500 if (sig < 1 || sig > TARGET_NSIG) 501 return; 502 #if defined(DEBUG_SIGNAL) 503 fprintf(stderr, "qemu: got signal %d\n", sig); 504 #endif 505 host_to_target_siginfo_noswap(&tinfo, info); 506 if (queue_signal(thread_env, sig, &tinfo) == 1) { 507 /* interrupt the virtual CPU as soon as possible */ 508 cpu_exit(thread_env); 509 } 510 } 511 512 /* do_sigaltstack() returns target values and errnos. */ 513 /* compare linux/kernel/signal.c:do_sigaltstack() */ 514 abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp) 515 { 516 int ret; 517 struct target_sigaltstack oss; 518 519 /* XXX: test errors */ 520 if(uoss_addr) 521 { 522 __put_user(target_sigaltstack_used.ss_sp, &oss.ss_sp); 523 __put_user(target_sigaltstack_used.ss_size, &oss.ss_size); 524 __put_user(sas_ss_flags(sp), &oss.ss_flags); 525 } 526 527 if(uss_addr) 528 { 529 struct target_sigaltstack *uss; 530 struct target_sigaltstack ss; 531 532 ret = -TARGET_EFAULT; 533 if (!lock_user_struct(VERIFY_READ, uss, uss_addr, 1) 534 || __get_user(ss.ss_sp, &uss->ss_sp) 535 || __get_user(ss.ss_size, &uss->ss_size) 536 || __get_user(ss.ss_flags, &uss->ss_flags)) 537 goto out; 538 unlock_user_struct(uss, uss_addr, 0); 539 540 ret = -TARGET_EPERM; 541 if (on_sig_stack(sp)) 542 goto out; 543 544 ret = -TARGET_EINVAL; 545 if (ss.ss_flags != TARGET_SS_DISABLE 546 && ss.ss_flags != TARGET_SS_ONSTACK 547 && ss.ss_flags != 0) 548 goto out; 549 550 if (ss.ss_flags == TARGET_SS_DISABLE) { 551 ss.ss_size = 0; 552 ss.ss_sp = 0; 553 } else { 554 ret = -TARGET_ENOMEM; 555 if (ss.ss_size < MINSIGSTKSZ) 556 goto out; 557 } 558 559 target_sigaltstack_used.ss_sp = ss.ss_sp; 560 target_sigaltstack_used.ss_size = ss.ss_size; 561 } 562 563 if (uoss_addr) { 564 ret = -TARGET_EFAULT; 565 if (copy_to_user(uoss_addr, &oss, sizeof(oss))) 566 goto out; 567 } 568 569 ret = 0; 570 out: 571 return ret; 572 } 573 574 /* do_sigaction() return host values and errnos */ 575 int do_sigaction(int sig, const struct target_sigaction *act, 576 struct target_sigaction *oact) 577 { 578 struct target_sigaction *k; 579 struct sigaction act1; 580 int host_sig; 581 int ret = 0; 582 583 if (sig < 1 || sig > TARGET_NSIG || sig == TARGET_SIGKILL || sig == TARGET_SIGSTOP) 584 return -EINVAL; 585 k = &sigact_table[sig - 1]; 586 #if defined(DEBUG_SIGNAL) 587 fprintf(stderr, "sigaction sig=%d act=0x%p, oact=0x%p\n", 588 sig, act, oact); 589 #endif 590 if (oact) { 591 oact->_sa_handler = tswapl(k->_sa_handler); 592 oact->sa_flags = tswapl(k->sa_flags); 593 #if !defined(TARGET_MIPS) 594 oact->sa_restorer = tswapl(k->sa_restorer); 595 #endif 596 oact->sa_mask = k->sa_mask; 597 } 598 if (act) { 599 /* FIXME: This is not threadsafe. */ 600 k->_sa_handler = tswapl(act->_sa_handler); 601 k->sa_flags = tswapl(act->sa_flags); 602 #if !defined(TARGET_MIPS) 603 k->sa_restorer = tswapl(act->sa_restorer); 604 #endif 605 k->sa_mask = act->sa_mask; 606 607 /* we update the host linux signal state */ 608 host_sig = target_to_host_signal(sig); 609 if (host_sig != SIGSEGV && host_sig != SIGBUS) { 610 sigfillset(&act1.sa_mask); 611 act1.sa_flags = SA_SIGINFO; 612 if (k->sa_flags & TARGET_SA_RESTART) 613 act1.sa_flags |= SA_RESTART; 614 /* NOTE: it is important to update the host kernel signal 615 ignore state to avoid getting unexpected interrupted 616 syscalls */ 617 if (k->_sa_handler == TARGET_SIG_IGN) { 618 act1.sa_sigaction = (void *)SIG_IGN; 619 } else if (k->_sa_handler == TARGET_SIG_DFL) { 620 if (fatal_signal (sig)) 621 act1.sa_sigaction = host_signal_handler; 622 else 623 act1.sa_sigaction = (void *)SIG_DFL; 624 } else { 625 act1.sa_sigaction = host_signal_handler; 626 } 627 ret = sigaction(host_sig, &act1, NULL); 628 } 629 } 630 return ret; 631 } 632 633 static inline int copy_siginfo_to_user(target_siginfo_t *tinfo, 634 const target_siginfo_t *info) 635 { 636 tswap_siginfo(tinfo, info); 637 return 0; 638 } 639 640 static inline int current_exec_domain_sig(int sig) 641 { 642 return /* current->exec_domain && current->exec_domain->signal_invmap 643 && sig < 32 ? current->exec_domain->signal_invmap[sig] : */ sig; 644 } 645 646 #if defined(TARGET_I386) && TARGET_ABI_BITS == 32 647 648 /* from the Linux kernel */ 649 650 struct target_fpreg { 651 uint16_t significand[4]; 652 uint16_t exponent; 653 }; 654 655 struct target_fpxreg { 656 uint16_t significand[4]; 657 uint16_t exponent; 658 uint16_t padding[3]; 659 }; 660 661 struct target_xmmreg { 662 abi_ulong element[4]; 663 }; 664 665 struct target_fpstate { 666 /* Regular FPU environment */ 667 abi_ulong cw; 668 abi_ulong sw; 669 abi_ulong tag; 670 abi_ulong ipoff; 671 abi_ulong cssel; 672 abi_ulong dataoff; 673 abi_ulong datasel; 674 struct target_fpreg _st[8]; 675 uint16_t status; 676 uint16_t magic; /* 0xffff = regular FPU data only */ 677 678 /* FXSR FPU environment */ 679 abi_ulong _fxsr_env[6]; /* FXSR FPU env is ignored */ 680 abi_ulong mxcsr; 681 abi_ulong reserved; 682 struct target_fpxreg _fxsr_st[8]; /* FXSR FPU reg data is ignored */ 683 struct target_xmmreg _xmm[8]; 684 abi_ulong padding[56]; 685 }; 686 687 #define X86_FXSR_MAGIC 0x0000 688 689 struct target_sigcontext { 690 uint16_t gs, __gsh; 691 uint16_t fs, __fsh; 692 uint16_t es, __esh; 693 uint16_t ds, __dsh; 694 abi_ulong edi; 695 abi_ulong esi; 696 abi_ulong ebp; 697 abi_ulong esp; 698 abi_ulong ebx; 699 abi_ulong edx; 700 abi_ulong ecx; 701 abi_ulong eax; 702 abi_ulong trapno; 703 abi_ulong err; 704 abi_ulong eip; 705 uint16_t cs, __csh; 706 abi_ulong eflags; 707 abi_ulong esp_at_signal; 708 uint16_t ss, __ssh; 709 abi_ulong fpstate; /* pointer */ 710 abi_ulong oldmask; 711 abi_ulong cr2; 712 }; 713 714 struct target_ucontext { 715 abi_ulong tuc_flags; 716 abi_ulong tuc_link; 717 target_stack_t tuc_stack; 718 struct target_sigcontext tuc_mcontext; 719 target_sigset_t tuc_sigmask; /* mask last for extensibility */ 720 }; 721 722 struct sigframe 723 { 724 abi_ulong pretcode; 725 int sig; 726 struct target_sigcontext sc; 727 struct target_fpstate fpstate; 728 abi_ulong extramask[TARGET_NSIG_WORDS-1]; 729 char retcode[8]; 730 }; 731 732 struct rt_sigframe 733 { 734 abi_ulong pretcode; 735 int sig; 736 abi_ulong pinfo; 737 abi_ulong puc; 738 struct target_siginfo info; 739 struct target_ucontext uc; 740 struct target_fpstate fpstate; 741 char retcode[8]; 742 }; 743 744 /* 745 * Set up a signal frame. 746 */ 747 748 /* XXX: save x87 state */ 749 static int 750 setup_sigcontext(struct target_sigcontext *sc, struct target_fpstate *fpstate, 751 CPUX86State *env, abi_ulong mask, abi_ulong fpstate_addr) 752 { 753 int err = 0; 754 uint16_t magic; 755 756 /* already locked in setup_frame() */ 757 err |= __put_user(env->segs[R_GS].selector, (unsigned int *)&sc->gs); 758 err |= __put_user(env->segs[R_FS].selector, (unsigned int *)&sc->fs); 759 err |= __put_user(env->segs[R_ES].selector, (unsigned int *)&sc->es); 760 err |= __put_user(env->segs[R_DS].selector, (unsigned int *)&sc->ds); 761 err |= __put_user(env->regs[R_EDI], &sc->edi); 762 err |= __put_user(env->regs[R_ESI], &sc->esi); 763 err |= __put_user(env->regs[R_EBP], &sc->ebp); 764 err |= __put_user(env->regs[R_ESP], &sc->esp); 765 err |= __put_user(env->regs[R_EBX], &sc->ebx); 766 err |= __put_user(env->regs[R_EDX], &sc->edx); 767 err |= __put_user(env->regs[R_ECX], &sc->ecx); 768 err |= __put_user(env->regs[R_EAX], &sc->eax); 769 err |= __put_user(env->exception_index, &sc->trapno); 770 err |= __put_user(env->error_code, &sc->err); 771 err |= __put_user(env->eip, &sc->eip); 772 err |= __put_user(env->segs[R_CS].selector, (unsigned int *)&sc->cs); 773 err |= __put_user(env->eflags, &sc->eflags); 774 err |= __put_user(env->regs[R_ESP], &sc->esp_at_signal); 775 err |= __put_user(env->segs[R_SS].selector, (unsigned int *)&sc->ss); 776 777 cpu_x86_fsave(env, fpstate_addr, 1); 778 fpstate->status = fpstate->sw; 779 magic = 0xffff; 780 err |= __put_user(magic, &fpstate->magic); 781 err |= __put_user(fpstate_addr, &sc->fpstate); 782 783 /* non-iBCS2 extensions.. */ 784 err |= __put_user(mask, &sc->oldmask); 785 err |= __put_user(env->cr[2], &sc->cr2); 786 return err; 787 } 788 789 /* 790 * Determine which stack to use.. 791 */ 792 793 static inline abi_ulong 794 get_sigframe(struct target_sigaction *ka, CPUX86State *env, size_t frame_size) 795 { 796 unsigned long esp; 797 798 /* Default to using normal stack */ 799 esp = env->regs[R_ESP]; 800 /* This is the X/Open sanctioned signal stack switching. */ 801 if (ka->sa_flags & TARGET_SA_ONSTACK) { 802 if (sas_ss_flags(esp) == 0) 803 esp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 804 } 805 806 /* This is the legacy signal stack switching. */ 807 else 808 if ((env->segs[R_SS].selector & 0xffff) != __USER_DS && 809 !(ka->sa_flags & TARGET_SA_RESTORER) && 810 ka->sa_restorer) { 811 esp = (unsigned long) ka->sa_restorer; 812 } 813 return (esp - frame_size) & -8ul; 814 } 815 816 /* compare linux/arch/i386/kernel/signal.c:setup_frame() */ 817 static void setup_frame(int sig, struct target_sigaction *ka, 818 target_sigset_t *set, CPUX86State *env) 819 { 820 abi_ulong frame_addr; 821 struct sigframe *frame; 822 int i, err = 0; 823 824 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 825 826 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 827 goto give_sigsegv; 828 829 err |= __put_user(current_exec_domain_sig(sig), 830 &frame->sig); 831 if (err) 832 goto give_sigsegv; 833 834 setup_sigcontext(&frame->sc, &frame->fpstate, env, set->sig[0], 835 frame_addr + offsetof(struct sigframe, fpstate)); 836 if (err) 837 goto give_sigsegv; 838 839 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 840 if (__put_user(set->sig[i], &frame->extramask[i - 1])) 841 goto give_sigsegv; 842 } 843 844 /* Set up to return from userspace. If provided, use a stub 845 already in userspace. */ 846 if (ka->sa_flags & TARGET_SA_RESTORER) { 847 err |= __put_user(ka->sa_restorer, &frame->pretcode); 848 } else { 849 uint16_t val16; 850 abi_ulong retcode_addr; 851 retcode_addr = frame_addr + offsetof(struct sigframe, retcode); 852 err |= __put_user(retcode_addr, &frame->pretcode); 853 /* This is popl %eax ; movl $,%eax ; int $0x80 */ 854 val16 = 0xb858; 855 err |= __put_user(val16, (uint16_t *)(frame->retcode+0)); 856 err |= __put_user(TARGET_NR_sigreturn, (int *)(frame->retcode+2)); 857 val16 = 0x80cd; 858 err |= __put_user(val16, (uint16_t *)(frame->retcode+6)); 859 } 860 861 if (err) 862 goto give_sigsegv; 863 864 /* Set up registers for signal handler */ 865 env->regs[R_ESP] = frame_addr; 866 env->eip = ka->_sa_handler; 867 868 cpu_x86_load_seg(env, R_DS, __USER_DS); 869 cpu_x86_load_seg(env, R_ES, __USER_DS); 870 cpu_x86_load_seg(env, R_SS, __USER_DS); 871 cpu_x86_load_seg(env, R_CS, __USER_CS); 872 env->eflags &= ~TF_MASK; 873 874 unlock_user_struct(frame, frame_addr, 1); 875 876 return; 877 878 give_sigsegv: 879 unlock_user_struct(frame, frame_addr, 1); 880 if (sig == TARGET_SIGSEGV) 881 ka->_sa_handler = TARGET_SIG_DFL; 882 force_sig(TARGET_SIGSEGV /* , current */); 883 } 884 885 /* compare linux/arch/i386/kernel/signal.c:setup_rt_frame() */ 886 static void setup_rt_frame(int sig, struct target_sigaction *ka, 887 target_siginfo_t *info, 888 target_sigset_t *set, CPUX86State *env) 889 { 890 abi_ulong frame_addr, addr; 891 struct rt_sigframe *frame; 892 int i, err = 0; 893 894 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 895 896 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 897 goto give_sigsegv; 898 899 err |= __put_user(current_exec_domain_sig(sig), 900 &frame->sig); 901 addr = frame_addr + offsetof(struct rt_sigframe, info); 902 err |= __put_user(addr, &frame->pinfo); 903 addr = frame_addr + offsetof(struct rt_sigframe, uc); 904 err |= __put_user(addr, &frame->puc); 905 err |= copy_siginfo_to_user(&frame->info, info); 906 if (err) 907 goto give_sigsegv; 908 909 /* Create the ucontext. */ 910 err |= __put_user(0, &frame->uc.tuc_flags); 911 err |= __put_user(0, &frame->uc.tuc_link); 912 err |= __put_user(target_sigaltstack_used.ss_sp, 913 &frame->uc.tuc_stack.ss_sp); 914 err |= __put_user(sas_ss_flags(get_sp_from_cpustate(env)), 915 &frame->uc.tuc_stack.ss_flags); 916 err |= __put_user(target_sigaltstack_used.ss_size, 917 &frame->uc.tuc_stack.ss_size); 918 err |= setup_sigcontext(&frame->uc.tuc_mcontext, &frame->fpstate, 919 env, set->sig[0], 920 frame_addr + offsetof(struct rt_sigframe, fpstate)); 921 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 922 if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i])) 923 goto give_sigsegv; 924 } 925 926 /* Set up to return from userspace. If provided, use a stub 927 already in userspace. */ 928 if (ka->sa_flags & TARGET_SA_RESTORER) { 929 err |= __put_user(ka->sa_restorer, &frame->pretcode); 930 } else { 931 uint16_t val16; 932 addr = frame_addr + offsetof(struct rt_sigframe, retcode); 933 err |= __put_user(addr, &frame->pretcode); 934 /* This is movl $,%eax ; int $0x80 */ 935 err |= __put_user(0xb8, (char *)(frame->retcode+0)); 936 err |= __put_user(TARGET_NR_rt_sigreturn, (int *)(frame->retcode+1)); 937 val16 = 0x80cd; 938 err |= __put_user(val16, (uint16_t *)(frame->retcode+5)); 939 } 940 941 if (err) 942 goto give_sigsegv; 943 944 /* Set up registers for signal handler */ 945 env->regs[R_ESP] = frame_addr; 946 env->eip = ka->_sa_handler; 947 948 cpu_x86_load_seg(env, R_DS, __USER_DS); 949 cpu_x86_load_seg(env, R_ES, __USER_DS); 950 cpu_x86_load_seg(env, R_SS, __USER_DS); 951 cpu_x86_load_seg(env, R_CS, __USER_CS); 952 env->eflags &= ~TF_MASK; 953 954 unlock_user_struct(frame, frame_addr, 1); 955 956 return; 957 958 give_sigsegv: 959 unlock_user_struct(frame, frame_addr, 1); 960 if (sig == TARGET_SIGSEGV) 961 ka->_sa_handler = TARGET_SIG_DFL; 962 force_sig(TARGET_SIGSEGV /* , current */); 963 } 964 965 static int 966 restore_sigcontext(CPUX86State *env, struct target_sigcontext *sc, int *peax) 967 { 968 unsigned int err = 0; 969 abi_ulong fpstate_addr; 970 unsigned int tmpflags; 971 972 cpu_x86_load_seg(env, R_GS, tswap16(sc->gs)); 973 cpu_x86_load_seg(env, R_FS, tswap16(sc->fs)); 974 cpu_x86_load_seg(env, R_ES, tswap16(sc->es)); 975 cpu_x86_load_seg(env, R_DS, tswap16(sc->ds)); 976 977 env->regs[R_EDI] = tswapl(sc->edi); 978 env->regs[R_ESI] = tswapl(sc->esi); 979 env->regs[R_EBP] = tswapl(sc->ebp); 980 env->regs[R_ESP] = tswapl(sc->esp); 981 env->regs[R_EBX] = tswapl(sc->ebx); 982 env->regs[R_EDX] = tswapl(sc->edx); 983 env->regs[R_ECX] = tswapl(sc->ecx); 984 env->eip = tswapl(sc->eip); 985 986 cpu_x86_load_seg(env, R_CS, lduw(&sc->cs) | 3); 987 cpu_x86_load_seg(env, R_SS, lduw(&sc->ss) | 3); 988 989 tmpflags = tswapl(sc->eflags); 990 env->eflags = (env->eflags & ~0x40DD5) | (tmpflags & 0x40DD5); 991 // regs->orig_eax = -1; /* disable syscall checks */ 992 993 fpstate_addr = tswapl(sc->fpstate); 994 if (fpstate_addr != 0) { 995 if (!access_ok(VERIFY_READ, fpstate_addr, 996 sizeof(struct target_fpstate))) 997 goto badframe; 998 cpu_x86_frstor(env, fpstate_addr, 1); 999 } 1000 1001 *peax = tswapl(sc->eax); 1002 return err; 1003 badframe: 1004 return 1; 1005 } 1006 1007 long do_sigreturn(CPUX86State *env) 1008 { 1009 struct sigframe *frame; 1010 abi_ulong frame_addr = env->regs[R_ESP] - 8; 1011 target_sigset_t target_set; 1012 sigset_t set; 1013 int eax, i; 1014 1015 #if defined(DEBUG_SIGNAL) 1016 fprintf(stderr, "do_sigreturn\n"); 1017 #endif 1018 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 1019 goto badframe; 1020 /* set blocked signals */ 1021 if (__get_user(target_set.sig[0], &frame->sc.oldmask)) 1022 goto badframe; 1023 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 1024 if (__get_user(target_set.sig[i], &frame->extramask[i - 1])) 1025 goto badframe; 1026 } 1027 1028 target_to_host_sigset_internal(&set, &target_set); 1029 sigprocmask(SIG_SETMASK, &set, NULL); 1030 1031 /* restore registers */ 1032 if (restore_sigcontext(env, &frame->sc, &eax)) 1033 goto badframe; 1034 unlock_user_struct(frame, frame_addr, 0); 1035 return eax; 1036 1037 badframe: 1038 unlock_user_struct(frame, frame_addr, 0); 1039 force_sig(TARGET_SIGSEGV); 1040 return 0; 1041 } 1042 1043 long do_rt_sigreturn(CPUX86State *env) 1044 { 1045 abi_ulong frame_addr; 1046 struct rt_sigframe *frame; 1047 sigset_t set; 1048 int eax; 1049 1050 frame_addr = env->regs[R_ESP] - 4; 1051 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 1052 goto badframe; 1053 target_to_host_sigset(&set, &frame->uc.tuc_sigmask); 1054 sigprocmask(SIG_SETMASK, &set, NULL); 1055 1056 if (restore_sigcontext(env, &frame->uc.tuc_mcontext, &eax)) 1057 goto badframe; 1058 1059 if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe, uc.tuc_stack), 0, 1060 get_sp_from_cpustate(env)) == -EFAULT) 1061 goto badframe; 1062 1063 unlock_user_struct(frame, frame_addr, 0); 1064 return eax; 1065 1066 badframe: 1067 unlock_user_struct(frame, frame_addr, 0); 1068 force_sig(TARGET_SIGSEGV); 1069 return 0; 1070 } 1071 1072 #elif defined(TARGET_ARM) 1073 1074 struct target_sigcontext { 1075 abi_ulong trap_no; 1076 abi_ulong error_code; 1077 abi_ulong oldmask; 1078 abi_ulong arm_r0; 1079 abi_ulong arm_r1; 1080 abi_ulong arm_r2; 1081 abi_ulong arm_r3; 1082 abi_ulong arm_r4; 1083 abi_ulong arm_r5; 1084 abi_ulong arm_r6; 1085 abi_ulong arm_r7; 1086 abi_ulong arm_r8; 1087 abi_ulong arm_r9; 1088 abi_ulong arm_r10; 1089 abi_ulong arm_fp; 1090 abi_ulong arm_ip; 1091 abi_ulong arm_sp; 1092 abi_ulong arm_lr; 1093 abi_ulong arm_pc; 1094 abi_ulong arm_cpsr; 1095 abi_ulong fault_address; 1096 }; 1097 1098 struct target_ucontext_v1 { 1099 abi_ulong tuc_flags; 1100 abi_ulong tuc_link; 1101 target_stack_t tuc_stack; 1102 struct target_sigcontext tuc_mcontext; 1103 target_sigset_t tuc_sigmask; /* mask last for extensibility */ 1104 }; 1105 1106 struct target_ucontext_v2 { 1107 abi_ulong tuc_flags; 1108 abi_ulong tuc_link; 1109 target_stack_t tuc_stack; 1110 struct target_sigcontext tuc_mcontext; 1111 target_sigset_t tuc_sigmask; /* mask last for extensibility */ 1112 char __unused[128 - sizeof(sigset_t)]; 1113 abi_ulong tuc_regspace[128] __attribute__((__aligned__(8))); 1114 }; 1115 1116 struct sigframe_v1 1117 { 1118 struct target_sigcontext sc; 1119 abi_ulong extramask[TARGET_NSIG_WORDS-1]; 1120 abi_ulong retcode; 1121 }; 1122 1123 struct sigframe_v2 1124 { 1125 struct target_ucontext_v2 uc; 1126 abi_ulong retcode; 1127 }; 1128 1129 struct rt_sigframe_v1 1130 { 1131 abi_ulong pinfo; 1132 abi_ulong puc; 1133 struct target_siginfo info; 1134 struct target_ucontext_v1 uc; 1135 abi_ulong retcode; 1136 }; 1137 1138 struct rt_sigframe_v2 1139 { 1140 struct target_siginfo info; 1141 struct target_ucontext_v2 uc; 1142 abi_ulong retcode; 1143 }; 1144 1145 #define TARGET_CONFIG_CPU_32 1 1146 1147 /* 1148 * For ARM syscalls, we encode the syscall number into the instruction. 1149 */ 1150 #define SWI_SYS_SIGRETURN (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE)) 1151 #define SWI_SYS_RT_SIGRETURN (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE)) 1152 1153 /* 1154 * For Thumb syscalls, we pass the syscall number via r7. We therefore 1155 * need two 16-bit instructions. 1156 */ 1157 #define SWI_THUMB_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn)) 1158 #define SWI_THUMB_RT_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn)) 1159 1160 static const abi_ulong retcodes[4] = { 1161 SWI_SYS_SIGRETURN, SWI_THUMB_SIGRETURN, 1162 SWI_SYS_RT_SIGRETURN, SWI_THUMB_RT_SIGRETURN 1163 }; 1164 1165 1166 #define __get_user_error(x,p,e) __get_user(x, p) 1167 1168 static inline int valid_user_regs(CPUState *regs) 1169 { 1170 return 1; 1171 } 1172 1173 static void 1174 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/ 1175 CPUState *env, abi_ulong mask) 1176 { 1177 __put_user(env->regs[0], &sc->arm_r0); 1178 __put_user(env->regs[1], &sc->arm_r1); 1179 __put_user(env->regs[2], &sc->arm_r2); 1180 __put_user(env->regs[3], &sc->arm_r3); 1181 __put_user(env->regs[4], &sc->arm_r4); 1182 __put_user(env->regs[5], &sc->arm_r5); 1183 __put_user(env->regs[6], &sc->arm_r6); 1184 __put_user(env->regs[7], &sc->arm_r7); 1185 __put_user(env->regs[8], &sc->arm_r8); 1186 __put_user(env->regs[9], &sc->arm_r9); 1187 __put_user(env->regs[10], &sc->arm_r10); 1188 __put_user(env->regs[11], &sc->arm_fp); 1189 __put_user(env->regs[12], &sc->arm_ip); 1190 __put_user(env->regs[13], &sc->arm_sp); 1191 __put_user(env->regs[14], &sc->arm_lr); 1192 __put_user(env->regs[15], &sc->arm_pc); 1193 #ifdef TARGET_CONFIG_CPU_32 1194 __put_user(cpsr_read(env), &sc->arm_cpsr); 1195 #endif 1196 1197 __put_user(/* current->thread.trap_no */ 0, &sc->trap_no); 1198 __put_user(/* current->thread.error_code */ 0, &sc->error_code); 1199 __put_user(/* current->thread.address */ 0, &sc->fault_address); 1200 __put_user(mask, &sc->oldmask); 1201 } 1202 1203 static inline abi_ulong 1204 get_sigframe(struct target_sigaction *ka, CPUState *regs, int framesize) 1205 { 1206 unsigned long sp = regs->regs[13]; 1207 1208 /* 1209 * This is the X/Open sanctioned signal stack switching. 1210 */ 1211 if ((ka->sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp)) 1212 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 1213 /* 1214 * ATPCS B01 mandates 8-byte alignment 1215 */ 1216 return (sp - framesize) & ~7; 1217 } 1218 1219 static int 1220 setup_return(CPUState *env, struct target_sigaction *ka, 1221 abi_ulong *rc, abi_ulong frame_addr, int usig, abi_ulong rc_addr) 1222 { 1223 abi_ulong handler = ka->_sa_handler; 1224 abi_ulong retcode; 1225 int thumb = handler & 1; 1226 1227 if (ka->sa_flags & TARGET_SA_RESTORER) { 1228 retcode = ka->sa_restorer; 1229 } else { 1230 unsigned int idx = thumb; 1231 1232 if (ka->sa_flags & TARGET_SA_SIGINFO) 1233 idx += 2; 1234 1235 if (__put_user(retcodes[idx], rc)) 1236 return 1; 1237 #if 0 1238 flush_icache_range((abi_ulong)rc, 1239 (abi_ulong)(rc + 1)); 1240 #endif 1241 retcode = rc_addr + thumb; 1242 } 1243 1244 env->regs[0] = usig; 1245 env->regs[13] = frame_addr; 1246 env->regs[14] = retcode; 1247 env->regs[15] = handler & (thumb ? ~1 : ~3); 1248 env->thumb = thumb; 1249 1250 #if 0 1251 #ifdef TARGET_CONFIG_CPU_32 1252 env->cpsr = cpsr; 1253 #endif 1254 #endif 1255 1256 return 0; 1257 } 1258 1259 static void setup_sigframe_v2(struct target_ucontext_v2 *uc, 1260 target_sigset_t *set, CPUState *env) 1261 { 1262 struct target_sigaltstack stack; 1263 int i; 1264 1265 /* Clear all the bits of the ucontext we don't use. */ 1266 memset(uc, 0, offsetof(struct target_ucontext_v2, tuc_mcontext)); 1267 1268 memset(&stack, 0, sizeof(stack)); 1269 __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp); 1270 __put_user(target_sigaltstack_used.ss_size, &stack.ss_size); 1271 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags); 1272 memcpy(&uc->tuc_stack, &stack, sizeof(stack)); 1273 1274 setup_sigcontext(&uc->tuc_mcontext, env, set->sig[0]); 1275 /* FIXME: Save coprocessor signal frame. */ 1276 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 1277 __put_user(set->sig[i], &uc->tuc_sigmask.sig[i]); 1278 } 1279 } 1280 1281 /* compare linux/arch/arm/kernel/signal.c:setup_frame() */ 1282 static void setup_frame_v1(int usig, struct target_sigaction *ka, 1283 target_sigset_t *set, CPUState *regs) 1284 { 1285 struct sigframe_v1 *frame; 1286 abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame)); 1287 int i; 1288 1289 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 1290 return; 1291 1292 setup_sigcontext(&frame->sc, regs, set->sig[0]); 1293 1294 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 1295 if (__put_user(set->sig[i], &frame->extramask[i - 1])) 1296 goto end; 1297 } 1298 1299 setup_return(regs, ka, &frame->retcode, frame_addr, usig, 1300 frame_addr + offsetof(struct sigframe_v1, retcode)); 1301 1302 end: 1303 unlock_user_struct(frame, frame_addr, 1); 1304 } 1305 1306 static void setup_frame_v2(int usig, struct target_sigaction *ka, 1307 target_sigset_t *set, CPUState *regs) 1308 { 1309 struct sigframe_v2 *frame; 1310 abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame)); 1311 1312 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 1313 return; 1314 1315 setup_sigframe_v2(&frame->uc, set, regs); 1316 1317 setup_return(regs, ka, &frame->retcode, frame_addr, usig, 1318 frame_addr + offsetof(struct sigframe_v2, retcode)); 1319 1320 unlock_user_struct(frame, frame_addr, 1); 1321 } 1322 1323 static void setup_frame(int usig, struct target_sigaction *ka, 1324 target_sigset_t *set, CPUState *regs) 1325 { 1326 if (get_osversion() >= 0x020612) { 1327 setup_frame_v2(usig, ka, set, regs); 1328 } else { 1329 setup_frame_v1(usig, ka, set, regs); 1330 } 1331 } 1332 1333 /* compare linux/arch/arm/kernel/signal.c:setup_rt_frame() */ 1334 static void setup_rt_frame_v1(int usig, struct target_sigaction *ka, 1335 target_siginfo_t *info, 1336 target_sigset_t *set, CPUState *env) 1337 { 1338 struct rt_sigframe_v1 *frame; 1339 abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame)); 1340 struct target_sigaltstack stack; 1341 int i; 1342 abi_ulong info_addr, uc_addr; 1343 1344 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 1345 return /* 1 */; 1346 1347 info_addr = frame_addr + offsetof(struct rt_sigframe_v1, info); 1348 __put_user(info_addr, &frame->pinfo); 1349 uc_addr = frame_addr + offsetof(struct rt_sigframe_v1, uc); 1350 __put_user(uc_addr, &frame->puc); 1351 copy_siginfo_to_user(&frame->info, info); 1352 1353 /* Clear all the bits of the ucontext we don't use. */ 1354 memset(&frame->uc, 0, offsetof(struct target_ucontext_v1, tuc_mcontext)); 1355 1356 memset(&stack, 0, sizeof(stack)); 1357 __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp); 1358 __put_user(target_sigaltstack_used.ss_size, &stack.ss_size); 1359 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags); 1360 memcpy(&frame->uc.tuc_stack, &stack, sizeof(stack)); 1361 1362 setup_sigcontext(&frame->uc.tuc_mcontext, env, set->sig[0]); 1363 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 1364 if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i])) 1365 goto end; 1366 } 1367 1368 setup_return(env, ka, &frame->retcode, frame_addr, usig, 1369 frame_addr + offsetof(struct rt_sigframe_v1, retcode)); 1370 1371 env->regs[1] = info_addr; 1372 env->regs[2] = uc_addr; 1373 1374 end: 1375 unlock_user_struct(frame, frame_addr, 1); 1376 } 1377 1378 static void setup_rt_frame_v2(int usig, struct target_sigaction *ka, 1379 target_siginfo_t *info, 1380 target_sigset_t *set, CPUState *env) 1381 { 1382 struct rt_sigframe_v2 *frame; 1383 abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame)); 1384 abi_ulong info_addr, uc_addr; 1385 1386 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 1387 return /* 1 */; 1388 1389 info_addr = frame_addr + offsetof(struct rt_sigframe_v2, info); 1390 uc_addr = frame_addr + offsetof(struct rt_sigframe_v2, uc); 1391 copy_siginfo_to_user(&frame->info, info); 1392 1393 setup_sigframe_v2(&frame->uc, set, env); 1394 1395 setup_return(env, ka, &frame->retcode, frame_addr, usig, 1396 frame_addr + offsetof(struct rt_sigframe_v2, retcode)); 1397 1398 env->regs[1] = info_addr; 1399 env->regs[2] = uc_addr; 1400 1401 unlock_user_struct(frame, frame_addr, 1); 1402 } 1403 1404 static void setup_rt_frame(int usig, struct target_sigaction *ka, 1405 target_siginfo_t *info, 1406 target_sigset_t *set, CPUState *env) 1407 { 1408 if (get_osversion() >= 0x020612) { 1409 setup_rt_frame_v2(usig, ka, info, set, env); 1410 } else { 1411 setup_rt_frame_v1(usig, ka, info, set, env); 1412 } 1413 } 1414 1415 static int 1416 restore_sigcontext(CPUState *env, struct target_sigcontext *sc) 1417 { 1418 int err = 0; 1419 uint32_t cpsr; 1420 1421 __get_user_error(env->regs[0], &sc->arm_r0, err); 1422 __get_user_error(env->regs[1], &sc->arm_r1, err); 1423 __get_user_error(env->regs[2], &sc->arm_r2, err); 1424 __get_user_error(env->regs[3], &sc->arm_r3, err); 1425 __get_user_error(env->regs[4], &sc->arm_r4, err); 1426 __get_user_error(env->regs[5], &sc->arm_r5, err); 1427 __get_user_error(env->regs[6], &sc->arm_r6, err); 1428 __get_user_error(env->regs[7], &sc->arm_r7, err); 1429 __get_user_error(env->regs[8], &sc->arm_r8, err); 1430 __get_user_error(env->regs[9], &sc->arm_r9, err); 1431 __get_user_error(env->regs[10], &sc->arm_r10, err); 1432 __get_user_error(env->regs[11], &sc->arm_fp, err); 1433 __get_user_error(env->regs[12], &sc->arm_ip, err); 1434 __get_user_error(env->regs[13], &sc->arm_sp, err); 1435 __get_user_error(env->regs[14], &sc->arm_lr, err); 1436 __get_user_error(env->regs[15], &sc->arm_pc, err); 1437 #ifdef TARGET_CONFIG_CPU_32 1438 __get_user_error(cpsr, &sc->arm_cpsr, err); 1439 cpsr_write(env, cpsr, CPSR_USER | CPSR_EXEC); 1440 #endif 1441 1442 err |= !valid_user_regs(env); 1443 1444 return err; 1445 } 1446 1447 static long do_sigreturn_v1(CPUState *env) 1448 { 1449 abi_ulong frame_addr; 1450 struct sigframe_v1 *frame; 1451 target_sigset_t set; 1452 sigset_t host_set; 1453 int i; 1454 1455 /* 1456 * Since we stacked the signal on a 64-bit boundary, 1457 * then 'sp' should be word aligned here. If it's 1458 * not, then the user is trying to mess with us. 1459 */ 1460 if (env->regs[13] & 7) 1461 goto badframe; 1462 1463 frame_addr = env->regs[13]; 1464 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 1465 goto badframe; 1466 1467 if (__get_user(set.sig[0], &frame->sc.oldmask)) 1468 goto badframe; 1469 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 1470 if (__get_user(set.sig[i], &frame->extramask[i - 1])) 1471 goto badframe; 1472 } 1473 1474 target_to_host_sigset_internal(&host_set, &set); 1475 sigprocmask(SIG_SETMASK, &host_set, NULL); 1476 1477 if (restore_sigcontext(env, &frame->sc)) 1478 goto badframe; 1479 1480 #if 0 1481 /* Send SIGTRAP if we're single-stepping */ 1482 if (ptrace_cancel_bpt(current)) 1483 send_sig(SIGTRAP, current, 1); 1484 #endif 1485 unlock_user_struct(frame, frame_addr, 0); 1486 return env->regs[0]; 1487 1488 badframe: 1489 unlock_user_struct(frame, frame_addr, 0); 1490 force_sig(TARGET_SIGSEGV /* , current */); 1491 return 0; 1492 } 1493 1494 static int do_sigframe_return_v2(CPUState *env, target_ulong frame_addr, 1495 struct target_ucontext_v2 *uc) 1496 { 1497 sigset_t host_set; 1498 1499 target_to_host_sigset(&host_set, &uc->tuc_sigmask); 1500 sigprocmask(SIG_SETMASK, &host_set, NULL); 1501 1502 if (restore_sigcontext(env, &uc->tuc_mcontext)) 1503 return 1; 1504 1505 if (do_sigaltstack(frame_addr + offsetof(struct target_ucontext_v2, tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT) 1506 return 1; 1507 1508 #if 0 1509 /* Send SIGTRAP if we're single-stepping */ 1510 if (ptrace_cancel_bpt(current)) 1511 send_sig(SIGTRAP, current, 1); 1512 #endif 1513 1514 return 0; 1515 } 1516 1517 static long do_sigreturn_v2(CPUState *env) 1518 { 1519 abi_ulong frame_addr; 1520 struct sigframe_v2 *frame; 1521 1522 /* 1523 * Since we stacked the signal on a 64-bit boundary, 1524 * then 'sp' should be word aligned here. If it's 1525 * not, then the user is trying to mess with us. 1526 */ 1527 if (env->regs[13] & 7) 1528 goto badframe; 1529 1530 frame_addr = env->regs[13]; 1531 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 1532 goto badframe; 1533 1534 if (do_sigframe_return_v2(env, frame_addr, &frame->uc)) 1535 goto badframe; 1536 1537 unlock_user_struct(frame, frame_addr, 0); 1538 return env->regs[0]; 1539 1540 badframe: 1541 unlock_user_struct(frame, frame_addr, 0); 1542 force_sig(TARGET_SIGSEGV /* , current */); 1543 return 0; 1544 } 1545 1546 long do_sigreturn(CPUState *env) 1547 { 1548 if (get_osversion() >= 0x020612) { 1549 return do_sigreturn_v2(env); 1550 } else { 1551 return do_sigreturn_v1(env); 1552 } 1553 } 1554 1555 static long do_rt_sigreturn_v1(CPUState *env) 1556 { 1557 abi_ulong frame_addr; 1558 struct rt_sigframe_v1 *frame; 1559 sigset_t host_set; 1560 1561 /* 1562 * Since we stacked the signal on a 64-bit boundary, 1563 * then 'sp' should be word aligned here. If it's 1564 * not, then the user is trying to mess with us. 1565 */ 1566 if (env->regs[13] & 7) 1567 goto badframe; 1568 1569 frame_addr = env->regs[13]; 1570 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 1571 goto badframe; 1572 1573 target_to_host_sigset(&host_set, &frame->uc.tuc_sigmask); 1574 sigprocmask(SIG_SETMASK, &host_set, NULL); 1575 1576 if (restore_sigcontext(env, &frame->uc.tuc_mcontext)) 1577 goto badframe; 1578 1579 if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe_v1, uc.tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT) 1580 goto badframe; 1581 1582 #if 0 1583 /* Send SIGTRAP if we're single-stepping */ 1584 if (ptrace_cancel_bpt(current)) 1585 send_sig(SIGTRAP, current, 1); 1586 #endif 1587 unlock_user_struct(frame, frame_addr, 0); 1588 return env->regs[0]; 1589 1590 badframe: 1591 unlock_user_struct(frame, frame_addr, 0); 1592 force_sig(TARGET_SIGSEGV /* , current */); 1593 return 0; 1594 } 1595 1596 static long do_rt_sigreturn_v2(CPUState *env) 1597 { 1598 abi_ulong frame_addr; 1599 struct rt_sigframe_v2 *frame; 1600 1601 /* 1602 * Since we stacked the signal on a 64-bit boundary, 1603 * then 'sp' should be word aligned here. If it's 1604 * not, then the user is trying to mess with us. 1605 */ 1606 if (env->regs[13] & 7) 1607 goto badframe; 1608 1609 frame_addr = env->regs[13]; 1610 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 1611 goto badframe; 1612 1613 if (do_sigframe_return_v2(env, frame_addr, &frame->uc)) 1614 goto badframe; 1615 1616 unlock_user_struct(frame, frame_addr, 0); 1617 return env->regs[0]; 1618 1619 badframe: 1620 unlock_user_struct(frame, frame_addr, 0); 1621 force_sig(TARGET_SIGSEGV /* , current */); 1622 return 0; 1623 } 1624 1625 long do_rt_sigreturn(CPUState *env) 1626 { 1627 if (get_osversion() >= 0x020612) { 1628 return do_rt_sigreturn_v2(env); 1629 } else { 1630 return do_rt_sigreturn_v1(env); 1631 } 1632 } 1633 1634 #elif defined(TARGET_SPARC) 1635 1636 #define __SUNOS_MAXWIN 31 1637 1638 /* This is what SunOS does, so shall I. */ 1639 struct target_sigcontext { 1640 abi_ulong sigc_onstack; /* state to restore */ 1641 1642 abi_ulong sigc_mask; /* sigmask to restore */ 1643 abi_ulong sigc_sp; /* stack pointer */ 1644 abi_ulong sigc_pc; /* program counter */ 1645 abi_ulong sigc_npc; /* next program counter */ 1646 abi_ulong sigc_psr; /* for condition codes etc */ 1647 abi_ulong sigc_g1; /* User uses these two registers */ 1648 abi_ulong sigc_o0; /* within the trampoline code. */ 1649 1650 /* Now comes information regarding the users window set 1651 * at the time of the signal. 1652 */ 1653 abi_ulong sigc_oswins; /* outstanding windows */ 1654 1655 /* stack ptrs for each regwin buf */ 1656 char *sigc_spbuf[__SUNOS_MAXWIN]; 1657 1658 /* Windows to restore after signal */ 1659 struct { 1660 abi_ulong locals[8]; 1661 abi_ulong ins[8]; 1662 } sigc_wbuf[__SUNOS_MAXWIN]; 1663 }; 1664 /* A Sparc stack frame */ 1665 struct sparc_stackf { 1666 abi_ulong locals[8]; 1667 abi_ulong ins[6]; 1668 struct sparc_stackf *fp; 1669 abi_ulong callers_pc; 1670 char *structptr; 1671 abi_ulong xargs[6]; 1672 abi_ulong xxargs[1]; 1673 }; 1674 1675 typedef struct { 1676 struct { 1677 abi_ulong psr; 1678 abi_ulong pc; 1679 abi_ulong npc; 1680 abi_ulong y; 1681 abi_ulong u_regs[16]; /* globals and ins */ 1682 } si_regs; 1683 int si_mask; 1684 } __siginfo_t; 1685 1686 typedef struct { 1687 unsigned long si_float_regs [32]; 1688 unsigned long si_fsr; 1689 unsigned long si_fpqdepth; 1690 struct { 1691 unsigned long *insn_addr; 1692 unsigned long insn; 1693 } si_fpqueue [16]; 1694 } qemu_siginfo_fpu_t; 1695 1696 1697 struct target_signal_frame { 1698 struct sparc_stackf ss; 1699 __siginfo_t info; 1700 abi_ulong fpu_save; 1701 abi_ulong insns[2] __attribute__ ((aligned (8))); 1702 abi_ulong extramask[TARGET_NSIG_WORDS - 1]; 1703 abi_ulong extra_size; /* Should be 0 */ 1704 qemu_siginfo_fpu_t fpu_state; 1705 }; 1706 struct target_rt_signal_frame { 1707 struct sparc_stackf ss; 1708 siginfo_t info; 1709 abi_ulong regs[20]; 1710 sigset_t mask; 1711 abi_ulong fpu_save; 1712 unsigned int insns[2]; 1713 stack_t stack; 1714 unsigned int extra_size; /* Should be 0 */ 1715 qemu_siginfo_fpu_t fpu_state; 1716 }; 1717 1718 #define UREG_O0 16 1719 #define UREG_O6 22 1720 #define UREG_I0 0 1721 #define UREG_I1 1 1722 #define UREG_I2 2 1723 #define UREG_I3 3 1724 #define UREG_I4 4 1725 #define UREG_I5 5 1726 #define UREG_I6 6 1727 #define UREG_I7 7 1728 #define UREG_L0 8 1729 #define UREG_FP UREG_I6 1730 #define UREG_SP UREG_O6 1731 1732 static inline abi_ulong get_sigframe(struct target_sigaction *sa, 1733 CPUState *env, unsigned long framesize) 1734 { 1735 abi_ulong sp; 1736 1737 sp = env->regwptr[UREG_FP]; 1738 1739 /* This is the X/Open sanctioned signal stack switching. */ 1740 if (sa->sa_flags & TARGET_SA_ONSTACK) { 1741 if (!on_sig_stack(sp) 1742 && !((target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size) & 7)) 1743 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 1744 } 1745 return sp - framesize; 1746 } 1747 1748 static int 1749 setup___siginfo(__siginfo_t *si, CPUState *env, abi_ulong mask) 1750 { 1751 int err = 0, i; 1752 1753 err |= __put_user(env->psr, &si->si_regs.psr); 1754 err |= __put_user(env->pc, &si->si_regs.pc); 1755 err |= __put_user(env->npc, &si->si_regs.npc); 1756 err |= __put_user(env->y, &si->si_regs.y); 1757 for (i=0; i < 8; i++) { 1758 err |= __put_user(env->gregs[i], &si->si_regs.u_regs[i]); 1759 } 1760 for (i=0; i < 8; i++) { 1761 err |= __put_user(env->regwptr[UREG_I0 + i], &si->si_regs.u_regs[i+8]); 1762 } 1763 err |= __put_user(mask, &si->si_mask); 1764 return err; 1765 } 1766 1767 #if 0 1768 static int 1769 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/ 1770 CPUState *env, unsigned long mask) 1771 { 1772 int err = 0; 1773 1774 err |= __put_user(mask, &sc->sigc_mask); 1775 err |= __put_user(env->regwptr[UREG_SP], &sc->sigc_sp); 1776 err |= __put_user(env->pc, &sc->sigc_pc); 1777 err |= __put_user(env->npc, &sc->sigc_npc); 1778 err |= __put_user(env->psr, &sc->sigc_psr); 1779 err |= __put_user(env->gregs[1], &sc->sigc_g1); 1780 err |= __put_user(env->regwptr[UREG_O0], &sc->sigc_o0); 1781 1782 return err; 1783 } 1784 #endif 1785 #define NF_ALIGNEDSZ (((sizeof(struct target_signal_frame) + 7) & (~7))) 1786 1787 static void setup_frame(int sig, struct target_sigaction *ka, 1788 target_sigset_t *set, CPUState *env) 1789 { 1790 abi_ulong sf_addr; 1791 struct target_signal_frame *sf; 1792 int sigframe_size, err, i; 1793 1794 /* 1. Make sure everything is clean */ 1795 //synchronize_user_stack(); 1796 1797 sigframe_size = NF_ALIGNEDSZ; 1798 sf_addr = get_sigframe(ka, env, sigframe_size); 1799 1800 sf = lock_user(VERIFY_WRITE, sf_addr, 1801 sizeof(struct target_signal_frame), 0); 1802 if (!sf) 1803 goto sigsegv; 1804 1805 //fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]); 1806 #if 0 1807 if (invalid_frame_pointer(sf, sigframe_size)) 1808 goto sigill_and_return; 1809 #endif 1810 /* 2. Save the current process state */ 1811 err = setup___siginfo(&sf->info, env, set->sig[0]); 1812 err |= __put_user(0, &sf->extra_size); 1813 1814 //err |= save_fpu_state(regs, &sf->fpu_state); 1815 //err |= __put_user(&sf->fpu_state, &sf->fpu_save); 1816 1817 err |= __put_user(set->sig[0], &sf->info.si_mask); 1818 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) { 1819 err |= __put_user(set->sig[i + 1], &sf->extramask[i]); 1820 } 1821 1822 for (i = 0; i < 8; i++) { 1823 err |= __put_user(env->regwptr[i + UREG_L0], &sf->ss.locals[i]); 1824 } 1825 for (i = 0; i < 8; i++) { 1826 err |= __put_user(env->regwptr[i + UREG_I0], &sf->ss.ins[i]); 1827 } 1828 if (err) 1829 goto sigsegv; 1830 1831 /* 3. signal handler back-trampoline and parameters */ 1832 env->regwptr[UREG_FP] = sf_addr; 1833 env->regwptr[UREG_I0] = sig; 1834 env->regwptr[UREG_I1] = sf_addr + 1835 offsetof(struct target_signal_frame, info); 1836 env->regwptr[UREG_I2] = sf_addr + 1837 offsetof(struct target_signal_frame, info); 1838 1839 /* 4. signal handler */ 1840 env->pc = ka->_sa_handler; 1841 env->npc = (env->pc + 4); 1842 /* 5. return to kernel instructions */ 1843 if (ka->sa_restorer) 1844 env->regwptr[UREG_I7] = ka->sa_restorer; 1845 else { 1846 uint32_t val32; 1847 1848 env->regwptr[UREG_I7] = sf_addr + 1849 offsetof(struct target_signal_frame, insns) - 2 * 4; 1850 1851 /* mov __NR_sigreturn, %g1 */ 1852 val32 = 0x821020d8; 1853 err |= __put_user(val32, &sf->insns[0]); 1854 1855 /* t 0x10 */ 1856 val32 = 0x91d02010; 1857 err |= __put_user(val32, &sf->insns[1]); 1858 if (err) 1859 goto sigsegv; 1860 1861 /* Flush instruction space. */ 1862 //flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0])); 1863 // tb_flush(env); 1864 } 1865 unlock_user(sf, sf_addr, sizeof(struct target_signal_frame)); 1866 return; 1867 #if 0 1868 sigill_and_return: 1869 force_sig(TARGET_SIGILL); 1870 #endif 1871 sigsegv: 1872 //fprintf(stderr, "force_sig\n"); 1873 unlock_user(sf, sf_addr, sizeof(struct target_signal_frame)); 1874 force_sig(TARGET_SIGSEGV); 1875 } 1876 static inline int 1877 restore_fpu_state(CPUState *env, qemu_siginfo_fpu_t *fpu) 1878 { 1879 int err; 1880 #if 0 1881 #ifdef CONFIG_SMP 1882 if (current->flags & PF_USEDFPU) 1883 regs->psr &= ~PSR_EF; 1884 #else 1885 if (current == last_task_used_math) { 1886 last_task_used_math = 0; 1887 regs->psr &= ~PSR_EF; 1888 } 1889 #endif 1890 current->used_math = 1; 1891 current->flags &= ~PF_USEDFPU; 1892 #endif 1893 #if 0 1894 if (verify_area (VERIFY_READ, fpu, sizeof(*fpu))) 1895 return -EFAULT; 1896 #endif 1897 1898 #if 0 1899 /* XXX: incorrect */ 1900 err = __copy_from_user(&env->fpr[0], &fpu->si_float_regs[0], 1901 (sizeof(unsigned long) * 32)); 1902 #endif 1903 err |= __get_user(env->fsr, &fpu->si_fsr); 1904 #if 0 1905 err |= __get_user(current->thread.fpqdepth, &fpu->si_fpqdepth); 1906 if (current->thread.fpqdepth != 0) 1907 err |= __copy_from_user(¤t->thread.fpqueue[0], 1908 &fpu->si_fpqueue[0], 1909 ((sizeof(unsigned long) + 1910 (sizeof(unsigned long *)))*16)); 1911 #endif 1912 return err; 1913 } 1914 1915 1916 static void setup_rt_frame(int sig, struct target_sigaction *ka, 1917 target_siginfo_t *info, 1918 target_sigset_t *set, CPUState *env) 1919 { 1920 fprintf(stderr, "setup_rt_frame: not implemented\n"); 1921 } 1922 1923 long do_sigreturn(CPUState *env) 1924 { 1925 abi_ulong sf_addr; 1926 struct target_signal_frame *sf; 1927 uint32_t up_psr, pc, npc; 1928 target_sigset_t set; 1929 sigset_t host_set; 1930 abi_ulong fpu_save_addr; 1931 int err, i; 1932 1933 sf_addr = env->regwptr[UREG_FP]; 1934 if (!lock_user_struct(VERIFY_READ, sf, sf_addr, 1)) 1935 goto segv_and_exit; 1936 #if 0 1937 fprintf(stderr, "sigreturn\n"); 1938 fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]); 1939 #endif 1940 //cpu_dump_state(env, stderr, fprintf, 0); 1941 1942 /* 1. Make sure we are not getting garbage from the user */ 1943 1944 if (sf_addr & 3) 1945 goto segv_and_exit; 1946 1947 err = __get_user(pc, &sf->info.si_regs.pc); 1948 err |= __get_user(npc, &sf->info.si_regs.npc); 1949 1950 if ((pc | npc) & 3) 1951 goto segv_and_exit; 1952 1953 /* 2. Restore the state */ 1954 err |= __get_user(up_psr, &sf->info.si_regs.psr); 1955 1956 /* User can only change condition codes and FPU enabling in %psr. */ 1957 env->psr = (up_psr & (PSR_ICC /* | PSR_EF */)) 1958 | (env->psr & ~(PSR_ICC /* | PSR_EF */)); 1959 1960 env->pc = pc; 1961 env->npc = npc; 1962 err |= __get_user(env->y, &sf->info.si_regs.y); 1963 for (i=0; i < 8; i++) { 1964 err |= __get_user(env->gregs[i], &sf->info.si_regs.u_regs[i]); 1965 } 1966 for (i=0; i < 8; i++) { 1967 err |= __get_user(env->regwptr[i + UREG_I0], &sf->info.si_regs.u_regs[i+8]); 1968 } 1969 1970 err |= __get_user(fpu_save_addr, &sf->fpu_save); 1971 1972 //if (fpu_save) 1973 // err |= restore_fpu_state(env, fpu_save); 1974 1975 /* This is pretty much atomic, no amount locking would prevent 1976 * the races which exist anyways. 1977 */ 1978 err |= __get_user(set.sig[0], &sf->info.si_mask); 1979 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 1980 err |= (__get_user(set.sig[i], &sf->extramask[i - 1])); 1981 } 1982 1983 target_to_host_sigset_internal(&host_set, &set); 1984 sigprocmask(SIG_SETMASK, &host_set, NULL); 1985 1986 if (err) 1987 goto segv_and_exit; 1988 unlock_user_struct(sf, sf_addr, 0); 1989 return env->regwptr[0]; 1990 1991 segv_and_exit: 1992 unlock_user_struct(sf, sf_addr, 0); 1993 force_sig(TARGET_SIGSEGV); 1994 } 1995 1996 long do_rt_sigreturn(CPUState *env) 1997 { 1998 fprintf(stderr, "do_rt_sigreturn: not implemented\n"); 1999 return -TARGET_ENOSYS; 2000 } 2001 2002 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32) 2003 #define MC_TSTATE 0 2004 #define MC_PC 1 2005 #define MC_NPC 2 2006 #define MC_Y 3 2007 #define MC_G1 4 2008 #define MC_G2 5 2009 #define MC_G3 6 2010 #define MC_G4 7 2011 #define MC_G5 8 2012 #define MC_G6 9 2013 #define MC_G7 10 2014 #define MC_O0 11 2015 #define MC_O1 12 2016 #define MC_O2 13 2017 #define MC_O3 14 2018 #define MC_O4 15 2019 #define MC_O5 16 2020 #define MC_O6 17 2021 #define MC_O7 18 2022 #define MC_NGREG 19 2023 2024 typedef abi_ulong target_mc_greg_t; 2025 typedef target_mc_greg_t target_mc_gregset_t[MC_NGREG]; 2026 2027 struct target_mc_fq { 2028 abi_ulong *mcfq_addr; 2029 uint32_t mcfq_insn; 2030 }; 2031 2032 struct target_mc_fpu { 2033 union { 2034 uint32_t sregs[32]; 2035 uint64_t dregs[32]; 2036 //uint128_t qregs[16]; 2037 } mcfpu_fregs; 2038 abi_ulong mcfpu_fsr; 2039 abi_ulong mcfpu_fprs; 2040 abi_ulong mcfpu_gsr; 2041 struct target_mc_fq *mcfpu_fq; 2042 unsigned char mcfpu_qcnt; 2043 unsigned char mcfpu_qentsz; 2044 unsigned char mcfpu_enab; 2045 }; 2046 typedef struct target_mc_fpu target_mc_fpu_t; 2047 2048 typedef struct { 2049 target_mc_gregset_t mc_gregs; 2050 target_mc_greg_t mc_fp; 2051 target_mc_greg_t mc_i7; 2052 target_mc_fpu_t mc_fpregs; 2053 } target_mcontext_t; 2054 2055 struct target_ucontext { 2056 struct target_ucontext *uc_link; 2057 abi_ulong uc_flags; 2058 target_sigset_t uc_sigmask; 2059 target_mcontext_t uc_mcontext; 2060 }; 2061 2062 /* A V9 register window */ 2063 struct target_reg_window { 2064 abi_ulong locals[8]; 2065 abi_ulong ins[8]; 2066 }; 2067 2068 #define TARGET_STACK_BIAS 2047 2069 2070 /* {set, get}context() needed for 64-bit SparcLinux userland. */ 2071 void sparc64_set_context(CPUSPARCState *env) 2072 { 2073 abi_ulong ucp_addr; 2074 struct target_ucontext *ucp; 2075 target_mc_gregset_t *grp; 2076 abi_ulong pc, npc, tstate; 2077 abi_ulong fp, i7, w_addr; 2078 unsigned char fenab; 2079 int err; 2080 unsigned int i; 2081 2082 ucp_addr = env->regwptr[UREG_I0]; 2083 if (!lock_user_struct(VERIFY_READ, ucp, ucp_addr, 1)) 2084 goto do_sigsegv; 2085 grp = &ucp->uc_mcontext.mc_gregs; 2086 err = __get_user(pc, &((*grp)[MC_PC])); 2087 err |= __get_user(npc, &((*grp)[MC_NPC])); 2088 if (err || ((pc | npc) & 3)) 2089 goto do_sigsegv; 2090 if (env->regwptr[UREG_I1]) { 2091 target_sigset_t target_set; 2092 sigset_t set; 2093 2094 if (TARGET_NSIG_WORDS == 1) { 2095 if (__get_user(target_set.sig[0], &ucp->uc_sigmask.sig[0])) 2096 goto do_sigsegv; 2097 } else { 2098 abi_ulong *src, *dst; 2099 src = ucp->uc_sigmask.sig; 2100 dst = target_set.sig; 2101 for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong); 2102 i++, dst++, src++) 2103 err |= __get_user(*dst, src); 2104 if (err) 2105 goto do_sigsegv; 2106 } 2107 target_to_host_sigset_internal(&set, &target_set); 2108 sigprocmask(SIG_SETMASK, &set, NULL); 2109 } 2110 env->pc = pc; 2111 env->npc = npc; 2112 err |= __get_user(env->y, &((*grp)[MC_Y])); 2113 err |= __get_user(tstate, &((*grp)[MC_TSTATE])); 2114 env->asi = (tstate >> 24) & 0xff; 2115 PUT_CCR(env, tstate >> 32); 2116 PUT_CWP64(env, tstate & 0x1f); 2117 err |= __get_user(env->gregs[1], (&(*grp)[MC_G1])); 2118 err |= __get_user(env->gregs[2], (&(*grp)[MC_G2])); 2119 err |= __get_user(env->gregs[3], (&(*grp)[MC_G3])); 2120 err |= __get_user(env->gregs[4], (&(*grp)[MC_G4])); 2121 err |= __get_user(env->gregs[5], (&(*grp)[MC_G5])); 2122 err |= __get_user(env->gregs[6], (&(*grp)[MC_G6])); 2123 err |= __get_user(env->gregs[7], (&(*grp)[MC_G7])); 2124 err |= __get_user(env->regwptr[UREG_I0], (&(*grp)[MC_O0])); 2125 err |= __get_user(env->regwptr[UREG_I1], (&(*grp)[MC_O1])); 2126 err |= __get_user(env->regwptr[UREG_I2], (&(*grp)[MC_O2])); 2127 err |= __get_user(env->regwptr[UREG_I3], (&(*grp)[MC_O3])); 2128 err |= __get_user(env->regwptr[UREG_I4], (&(*grp)[MC_O4])); 2129 err |= __get_user(env->regwptr[UREG_I5], (&(*grp)[MC_O5])); 2130 err |= __get_user(env->regwptr[UREG_I6], (&(*grp)[MC_O6])); 2131 err |= __get_user(env->regwptr[UREG_I7], (&(*grp)[MC_O7])); 2132 2133 err |= __get_user(fp, &(ucp->uc_mcontext.mc_fp)); 2134 err |= __get_user(i7, &(ucp->uc_mcontext.mc_i7)); 2135 2136 w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6]; 2137 if (put_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]), 2138 abi_ulong) != 0) 2139 goto do_sigsegv; 2140 if (put_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]), 2141 abi_ulong) != 0) 2142 goto do_sigsegv; 2143 err |= __get_user(fenab, &(ucp->uc_mcontext.mc_fpregs.mcfpu_enab)); 2144 err |= __get_user(env->fprs, &(ucp->uc_mcontext.mc_fpregs.mcfpu_fprs)); 2145 { 2146 uint32_t *src, *dst; 2147 src = ucp->uc_mcontext.mc_fpregs.mcfpu_fregs.sregs; 2148 dst = env->fpr; 2149 /* XXX: check that the CPU storage is the same as user context */ 2150 for (i = 0; i < 64; i++, dst++, src++) 2151 err |= __get_user(*dst, src); 2152 } 2153 err |= __get_user(env->fsr, 2154 &(ucp->uc_mcontext.mc_fpregs.mcfpu_fsr)); 2155 err |= __get_user(env->gsr, 2156 &(ucp->uc_mcontext.mc_fpregs.mcfpu_gsr)); 2157 if (err) 2158 goto do_sigsegv; 2159 unlock_user_struct(ucp, ucp_addr, 0); 2160 return; 2161 do_sigsegv: 2162 unlock_user_struct(ucp, ucp_addr, 0); 2163 force_sig(TARGET_SIGSEGV); 2164 } 2165 2166 void sparc64_get_context(CPUSPARCState *env) 2167 { 2168 abi_ulong ucp_addr; 2169 struct target_ucontext *ucp; 2170 target_mc_gregset_t *grp; 2171 target_mcontext_t *mcp; 2172 abi_ulong fp, i7, w_addr; 2173 int err; 2174 unsigned int i; 2175 target_sigset_t target_set; 2176 sigset_t set; 2177 2178 ucp_addr = env->regwptr[UREG_I0]; 2179 if (!lock_user_struct(VERIFY_WRITE, ucp, ucp_addr, 0)) 2180 goto do_sigsegv; 2181 2182 mcp = &ucp->uc_mcontext; 2183 grp = &mcp->mc_gregs; 2184 2185 /* Skip over the trap instruction, first. */ 2186 env->pc = env->npc; 2187 env->npc += 4; 2188 2189 err = 0; 2190 2191 sigprocmask(0, NULL, &set); 2192 host_to_target_sigset_internal(&target_set, &set); 2193 if (TARGET_NSIG_WORDS == 1) { 2194 err |= __put_user(target_set.sig[0], 2195 (abi_ulong *)&ucp->uc_sigmask); 2196 } else { 2197 abi_ulong *src, *dst; 2198 src = target_set.sig; 2199 dst = ucp->uc_sigmask.sig; 2200 for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong); 2201 i++, dst++, src++) 2202 err |= __put_user(*src, dst); 2203 if (err) 2204 goto do_sigsegv; 2205 } 2206 2207 /* XXX: tstate must be saved properly */ 2208 // err |= __put_user(env->tstate, &((*grp)[MC_TSTATE])); 2209 err |= __put_user(env->pc, &((*grp)[MC_PC])); 2210 err |= __put_user(env->npc, &((*grp)[MC_NPC])); 2211 err |= __put_user(env->y, &((*grp)[MC_Y])); 2212 err |= __put_user(env->gregs[1], &((*grp)[MC_G1])); 2213 err |= __put_user(env->gregs[2], &((*grp)[MC_G2])); 2214 err |= __put_user(env->gregs[3], &((*grp)[MC_G3])); 2215 err |= __put_user(env->gregs[4], &((*grp)[MC_G4])); 2216 err |= __put_user(env->gregs[5], &((*grp)[MC_G5])); 2217 err |= __put_user(env->gregs[6], &((*grp)[MC_G6])); 2218 err |= __put_user(env->gregs[7], &((*grp)[MC_G7])); 2219 err |= __put_user(env->regwptr[UREG_I0], &((*grp)[MC_O0])); 2220 err |= __put_user(env->regwptr[UREG_I1], &((*grp)[MC_O1])); 2221 err |= __put_user(env->regwptr[UREG_I2], &((*grp)[MC_O2])); 2222 err |= __put_user(env->regwptr[UREG_I3], &((*grp)[MC_O3])); 2223 err |= __put_user(env->regwptr[UREG_I4], &((*grp)[MC_O4])); 2224 err |= __put_user(env->regwptr[UREG_I5], &((*grp)[MC_O5])); 2225 err |= __put_user(env->regwptr[UREG_I6], &((*grp)[MC_O6])); 2226 err |= __put_user(env->regwptr[UREG_I7], &((*grp)[MC_O7])); 2227 2228 w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6]; 2229 fp = i7 = 0; 2230 if (get_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]), 2231 abi_ulong) != 0) 2232 goto do_sigsegv; 2233 if (get_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]), 2234 abi_ulong) != 0) 2235 goto do_sigsegv; 2236 err |= __put_user(fp, &(mcp->mc_fp)); 2237 err |= __put_user(i7, &(mcp->mc_i7)); 2238 2239 { 2240 uint32_t *src, *dst; 2241 src = env->fpr; 2242 dst = ucp->uc_mcontext.mc_fpregs.mcfpu_fregs.sregs; 2243 /* XXX: check that the CPU storage is the same as user context */ 2244 for (i = 0; i < 64; i++, dst++, src++) 2245 err |= __put_user(*src, dst); 2246 } 2247 err |= __put_user(env->fsr, &(mcp->mc_fpregs.mcfpu_fsr)); 2248 err |= __put_user(env->gsr, &(mcp->mc_fpregs.mcfpu_gsr)); 2249 err |= __put_user(env->fprs, &(mcp->mc_fpregs.mcfpu_fprs)); 2250 2251 if (err) 2252 goto do_sigsegv; 2253 unlock_user_struct(ucp, ucp_addr, 1); 2254 return; 2255 do_sigsegv: 2256 unlock_user_struct(ucp, ucp_addr, 1); 2257 force_sig(TARGET_SIGSEGV); 2258 } 2259 #endif 2260 #elif defined(TARGET_ABI_MIPSN64) 2261 2262 # warning signal handling not implemented 2263 2264 static void setup_frame(int sig, struct target_sigaction *ka, 2265 target_sigset_t *set, CPUState *env) 2266 { 2267 fprintf(stderr, "setup_frame: not implemented\n"); 2268 } 2269 2270 static void setup_rt_frame(int sig, struct target_sigaction *ka, 2271 target_siginfo_t *info, 2272 target_sigset_t *set, CPUState *env) 2273 { 2274 fprintf(stderr, "setup_rt_frame: not implemented\n"); 2275 } 2276 2277 long do_sigreturn(CPUState *env) 2278 { 2279 fprintf(stderr, "do_sigreturn: not implemented\n"); 2280 return -TARGET_ENOSYS; 2281 } 2282 2283 long do_rt_sigreturn(CPUState *env) 2284 { 2285 fprintf(stderr, "do_rt_sigreturn: not implemented\n"); 2286 return -TARGET_ENOSYS; 2287 } 2288 2289 #elif defined(TARGET_ABI_MIPSN32) 2290 2291 # warning signal handling not implemented 2292 2293 static void setup_frame(int sig, struct target_sigaction *ka, 2294 target_sigset_t *set, CPUState *env) 2295 { 2296 fprintf(stderr, "setup_frame: not implemented\n"); 2297 } 2298 2299 static void setup_rt_frame(int sig, struct target_sigaction *ka, 2300 target_siginfo_t *info, 2301 target_sigset_t *set, CPUState *env) 2302 { 2303 fprintf(stderr, "setup_rt_frame: not implemented\n"); 2304 } 2305 2306 long do_sigreturn(CPUState *env) 2307 { 2308 fprintf(stderr, "do_sigreturn: not implemented\n"); 2309 return -TARGET_ENOSYS; 2310 } 2311 2312 long do_rt_sigreturn(CPUState *env) 2313 { 2314 fprintf(stderr, "do_rt_sigreturn: not implemented\n"); 2315 return -TARGET_ENOSYS; 2316 } 2317 2318 #elif defined(TARGET_ABI_MIPSO32) 2319 2320 struct target_sigcontext { 2321 uint32_t sc_regmask; /* Unused */ 2322 uint32_t sc_status; 2323 uint64_t sc_pc; 2324 uint64_t sc_regs[32]; 2325 uint64_t sc_fpregs[32]; 2326 uint32_t sc_ownedfp; /* Unused */ 2327 uint32_t sc_fpc_csr; 2328 uint32_t sc_fpc_eir; /* Unused */ 2329 uint32_t sc_used_math; 2330 uint32_t sc_dsp; /* dsp status, was sc_ssflags */ 2331 uint32_t pad0; 2332 uint64_t sc_mdhi; 2333 uint64_t sc_mdlo; 2334 target_ulong sc_hi1; /* Was sc_cause */ 2335 target_ulong sc_lo1; /* Was sc_badvaddr */ 2336 target_ulong sc_hi2; /* Was sc_sigset[4] */ 2337 target_ulong sc_lo2; 2338 target_ulong sc_hi3; 2339 target_ulong sc_lo3; 2340 }; 2341 2342 struct sigframe { 2343 uint32_t sf_ass[4]; /* argument save space for o32 */ 2344 uint32_t sf_code[2]; /* signal trampoline */ 2345 struct target_sigcontext sf_sc; 2346 target_sigset_t sf_mask; 2347 }; 2348 2349 struct target_ucontext { 2350 target_ulong uc_flags; 2351 target_ulong uc_link; 2352 target_stack_t uc_stack; 2353 target_ulong pad0; 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 int i; 2816 2817 #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x) 2818 COPY(gregs[0]); COPY(gregs[1]); 2819 COPY(gregs[2]); COPY(gregs[3]); 2820 COPY(gregs[4]); COPY(gregs[5]); 2821 COPY(gregs[6]); COPY(gregs[7]); 2822 COPY(gregs[8]); COPY(gregs[9]); 2823 COPY(gregs[10]); COPY(gregs[11]); 2824 COPY(gregs[12]); COPY(gregs[13]); 2825 COPY(gregs[14]); COPY(gregs[15]); 2826 COPY(gbr); COPY(mach); 2827 COPY(macl); COPY(pr); 2828 COPY(sr); COPY(pc); 2829 #undef COPY 2830 2831 for (i=0; i<16; i++) { 2832 err |= __put_user(regs->fregs[i], &sc->sc_fpregs[i]); 2833 } 2834 err |= __put_user(regs->fpscr, &sc->sc_fpscr); 2835 err |= __put_user(regs->fpul, &sc->sc_fpul); 2836 2837 /* non-iBCS2 extensions.. */ 2838 err |= __put_user(mask, &sc->oldmask); 2839 2840 return err; 2841 } 2842 2843 static int restore_sigcontext(CPUState *regs, struct target_sigcontext *sc, 2844 target_ulong *r0_p) 2845 { 2846 unsigned int err = 0; 2847 int i; 2848 2849 #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x) 2850 COPY(gregs[1]); 2851 COPY(gregs[2]); COPY(gregs[3]); 2852 COPY(gregs[4]); COPY(gregs[5]); 2853 COPY(gregs[6]); COPY(gregs[7]); 2854 COPY(gregs[8]); COPY(gregs[9]); 2855 COPY(gregs[10]); COPY(gregs[11]); 2856 COPY(gregs[12]); COPY(gregs[13]); 2857 COPY(gregs[14]); COPY(gregs[15]); 2858 COPY(gbr); COPY(mach); 2859 COPY(macl); COPY(pr); 2860 COPY(sr); COPY(pc); 2861 #undef COPY 2862 2863 for (i=0; i<16; i++) { 2864 err |= __get_user(regs->fregs[i], &sc->sc_fpregs[i]); 2865 } 2866 err |= __get_user(regs->fpscr, &sc->sc_fpscr); 2867 err |= __get_user(regs->fpul, &sc->sc_fpul); 2868 2869 regs->tra = -1; /* disable syscall checks */ 2870 err |= __get_user(*r0_p, &sc->sc_gregs[0]); 2871 return err; 2872 } 2873 2874 static void setup_frame(int sig, struct target_sigaction *ka, 2875 target_sigset_t *set, CPUState *regs) 2876 { 2877 struct target_sigframe *frame; 2878 abi_ulong frame_addr; 2879 int i; 2880 int err = 0; 2881 int signal; 2882 2883 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame)); 2884 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 2885 goto give_sigsegv; 2886 2887 signal = current_exec_domain_sig(sig); 2888 2889 err |= setup_sigcontext(&frame->sc, regs, set->sig[0]); 2890 2891 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) { 2892 err |= __put_user(set->sig[i + 1], &frame->extramask[i]); 2893 } 2894 2895 /* Set up to return from userspace. If provided, use a stub 2896 already in userspace. */ 2897 if (ka->sa_flags & TARGET_SA_RESTORER) { 2898 regs->pr = (unsigned long) ka->sa_restorer; 2899 } else { 2900 /* Generate return code (system call to sigreturn) */ 2901 err |= __put_user(MOVW(2), &frame->retcode[0]); 2902 err |= __put_user(TRAP_NOARG, &frame->retcode[1]); 2903 err |= __put_user((TARGET_NR_sigreturn), &frame->retcode[2]); 2904 regs->pr = (unsigned long) frame->retcode; 2905 } 2906 2907 if (err) 2908 goto give_sigsegv; 2909 2910 /* Set up registers for signal handler */ 2911 regs->gregs[15] = (unsigned long) frame; 2912 regs->gregs[4] = signal; /* Arg for signal handler */ 2913 regs->gregs[5] = 0; 2914 regs->gregs[6] = (unsigned long) &frame->sc; 2915 regs->pc = (unsigned long) ka->_sa_handler; 2916 2917 unlock_user_struct(frame, frame_addr, 1); 2918 return; 2919 2920 give_sigsegv: 2921 unlock_user_struct(frame, frame_addr, 1); 2922 force_sig(TARGET_SIGSEGV); 2923 } 2924 2925 static void setup_rt_frame(int sig, struct target_sigaction *ka, 2926 target_siginfo_t *info, 2927 target_sigset_t *set, CPUState *regs) 2928 { 2929 struct target_rt_sigframe *frame; 2930 abi_ulong frame_addr; 2931 int i; 2932 int err = 0; 2933 int signal; 2934 2935 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame)); 2936 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 2937 goto give_sigsegv; 2938 2939 signal = current_exec_domain_sig(sig); 2940 2941 err |= copy_siginfo_to_user(&frame->info, info); 2942 2943 /* Create the ucontext. */ 2944 err |= __put_user(0, &frame->uc.uc_flags); 2945 err |= __put_user(0, (unsigned long *)&frame->uc.uc_link); 2946 err |= __put_user((unsigned long)target_sigaltstack_used.ss_sp, 2947 &frame->uc.uc_stack.ss_sp); 2948 err |= __put_user(sas_ss_flags(regs->gregs[15]), 2949 &frame->uc.uc_stack.ss_flags); 2950 err |= __put_user(target_sigaltstack_used.ss_size, 2951 &frame->uc.uc_stack.ss_size); 2952 err |= setup_sigcontext(&frame->uc.uc_mcontext, 2953 regs, set->sig[0]); 2954 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 2955 err |= __put_user(set->sig[i], &frame->uc.uc_sigmask.sig[i]); 2956 } 2957 2958 /* Set up to return from userspace. If provided, use a stub 2959 already in userspace. */ 2960 if (ka->sa_flags & TARGET_SA_RESTORER) { 2961 regs->pr = (unsigned long) ka->sa_restorer; 2962 } else { 2963 /* Generate return code (system call to sigreturn) */ 2964 err |= __put_user(MOVW(2), &frame->retcode[0]); 2965 err |= __put_user(TRAP_NOARG, &frame->retcode[1]); 2966 err |= __put_user((TARGET_NR_rt_sigreturn), &frame->retcode[2]); 2967 regs->pr = (unsigned long) frame->retcode; 2968 } 2969 2970 if (err) 2971 goto give_sigsegv; 2972 2973 /* Set up registers for signal handler */ 2974 regs->gregs[15] = (unsigned long) frame; 2975 regs->gregs[4] = signal; /* Arg for signal handler */ 2976 regs->gregs[5] = (unsigned long) &frame->info; 2977 regs->gregs[6] = (unsigned long) &frame->uc; 2978 regs->pc = (unsigned long) ka->_sa_handler; 2979 2980 unlock_user_struct(frame, frame_addr, 1); 2981 return; 2982 2983 give_sigsegv: 2984 unlock_user_struct(frame, frame_addr, 1); 2985 force_sig(TARGET_SIGSEGV); 2986 } 2987 2988 long do_sigreturn(CPUState *regs) 2989 { 2990 struct target_sigframe *frame; 2991 abi_ulong frame_addr; 2992 sigset_t blocked; 2993 target_sigset_t target_set; 2994 target_ulong r0; 2995 int i; 2996 int err = 0; 2997 2998 #if defined(DEBUG_SIGNAL) 2999 fprintf(stderr, "do_sigreturn\n"); 3000 #endif 3001 frame_addr = regs->gregs[15]; 3002 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 3003 goto badframe; 3004 3005 err |= __get_user(target_set.sig[0], &frame->sc.oldmask); 3006 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 3007 err |= (__get_user(target_set.sig[i], &frame->extramask[i - 1])); 3008 } 3009 3010 if (err) 3011 goto badframe; 3012 3013 target_to_host_sigset_internal(&blocked, &target_set); 3014 sigprocmask(SIG_SETMASK, &blocked, NULL); 3015 3016 if (restore_sigcontext(regs, &frame->sc, &r0)) 3017 goto badframe; 3018 3019 unlock_user_struct(frame, frame_addr, 0); 3020 return r0; 3021 3022 badframe: 3023 unlock_user_struct(frame, frame_addr, 0); 3024 force_sig(TARGET_SIGSEGV); 3025 return 0; 3026 } 3027 3028 long do_rt_sigreturn(CPUState *regs) 3029 { 3030 struct target_rt_sigframe *frame; 3031 abi_ulong frame_addr; 3032 sigset_t blocked; 3033 target_ulong r0; 3034 3035 #if defined(DEBUG_SIGNAL) 3036 fprintf(stderr, "do_rt_sigreturn\n"); 3037 #endif 3038 frame_addr = regs->gregs[15]; 3039 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 3040 goto badframe; 3041 3042 target_to_host_sigset(&blocked, &frame->uc.uc_sigmask); 3043 sigprocmask(SIG_SETMASK, &blocked, NULL); 3044 3045 if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &r0)) 3046 goto badframe; 3047 3048 if (do_sigaltstack(frame_addr + 3049 offsetof(struct target_rt_sigframe, uc.uc_stack), 3050 0, get_sp_from_cpustate(regs)) == -EFAULT) 3051 goto badframe; 3052 3053 unlock_user_struct(frame, frame_addr, 0); 3054 return r0; 3055 3056 badframe: 3057 unlock_user_struct(frame, frame_addr, 0); 3058 force_sig(TARGET_SIGSEGV); 3059 return 0; 3060 } 3061 #elif defined(TARGET_MICROBLAZE) 3062 3063 struct target_sigcontext { 3064 struct target_pt_regs regs; /* needs to be first */ 3065 uint32_t oldmask; 3066 }; 3067 3068 /* Signal frames. */ 3069 struct target_signal_frame { 3070 struct target_sigcontext sc; 3071 uint32_t extramask[TARGET_NSIG_WORDS - 1]; 3072 uint32_t tramp[2]; 3073 }; 3074 3075 struct rt_signal_frame { 3076 struct siginfo info; 3077 struct ucontext uc; 3078 uint32_t tramp[2]; 3079 }; 3080 3081 static void setup_sigcontext(struct target_sigcontext *sc, CPUState *env) 3082 { 3083 __put_user(env->regs[0], &sc->regs.r0); 3084 __put_user(env->regs[1], &sc->regs.r1); 3085 __put_user(env->regs[2], &sc->regs.r2); 3086 __put_user(env->regs[3], &sc->regs.r3); 3087 __put_user(env->regs[4], &sc->regs.r4); 3088 __put_user(env->regs[5], &sc->regs.r5); 3089 __put_user(env->regs[6], &sc->regs.r6); 3090 __put_user(env->regs[7], &sc->regs.r7); 3091 __put_user(env->regs[8], &sc->regs.r8); 3092 __put_user(env->regs[9], &sc->regs.r9); 3093 __put_user(env->regs[10], &sc->regs.r10); 3094 __put_user(env->regs[11], &sc->regs.r11); 3095 __put_user(env->regs[12], &sc->regs.r12); 3096 __put_user(env->regs[13], &sc->regs.r13); 3097 __put_user(env->regs[14], &sc->regs.r14); 3098 __put_user(env->regs[15], &sc->regs.r15); 3099 __put_user(env->regs[16], &sc->regs.r16); 3100 __put_user(env->regs[17], &sc->regs.r17); 3101 __put_user(env->regs[18], &sc->regs.r18); 3102 __put_user(env->regs[19], &sc->regs.r19); 3103 __put_user(env->regs[20], &sc->regs.r20); 3104 __put_user(env->regs[21], &sc->regs.r21); 3105 __put_user(env->regs[22], &sc->regs.r22); 3106 __put_user(env->regs[23], &sc->regs.r23); 3107 __put_user(env->regs[24], &sc->regs.r24); 3108 __put_user(env->regs[25], &sc->regs.r25); 3109 __put_user(env->regs[26], &sc->regs.r26); 3110 __put_user(env->regs[27], &sc->regs.r27); 3111 __put_user(env->regs[28], &sc->regs.r28); 3112 __put_user(env->regs[29], &sc->regs.r29); 3113 __put_user(env->regs[30], &sc->regs.r30); 3114 __put_user(env->regs[31], &sc->regs.r31); 3115 __put_user(env->sregs[SR_PC], &sc->regs.pc); 3116 } 3117 3118 static void restore_sigcontext(struct target_sigcontext *sc, CPUState *env) 3119 { 3120 __get_user(env->regs[0], &sc->regs.r0); 3121 __get_user(env->regs[1], &sc->regs.r1); 3122 __get_user(env->regs[2], &sc->regs.r2); 3123 __get_user(env->regs[3], &sc->regs.r3); 3124 __get_user(env->regs[4], &sc->regs.r4); 3125 __get_user(env->regs[5], &sc->regs.r5); 3126 __get_user(env->regs[6], &sc->regs.r6); 3127 __get_user(env->regs[7], &sc->regs.r7); 3128 __get_user(env->regs[8], &sc->regs.r8); 3129 __get_user(env->regs[9], &sc->regs.r9); 3130 __get_user(env->regs[10], &sc->regs.r10); 3131 __get_user(env->regs[11], &sc->regs.r11); 3132 __get_user(env->regs[12], &sc->regs.r12); 3133 __get_user(env->regs[13], &sc->regs.r13); 3134 __get_user(env->regs[14], &sc->regs.r14); 3135 __get_user(env->regs[15], &sc->regs.r15); 3136 __get_user(env->regs[16], &sc->regs.r16); 3137 __get_user(env->regs[17], &sc->regs.r17); 3138 __get_user(env->regs[18], &sc->regs.r18); 3139 __get_user(env->regs[19], &sc->regs.r19); 3140 __get_user(env->regs[20], &sc->regs.r20); 3141 __get_user(env->regs[21], &sc->regs.r21); 3142 __get_user(env->regs[22], &sc->regs.r22); 3143 __get_user(env->regs[23], &sc->regs.r23); 3144 __get_user(env->regs[24], &sc->regs.r24); 3145 __get_user(env->regs[25], &sc->regs.r25); 3146 __get_user(env->regs[26], &sc->regs.r26); 3147 __get_user(env->regs[27], &sc->regs.r27); 3148 __get_user(env->regs[28], &sc->regs.r28); 3149 __get_user(env->regs[29], &sc->regs.r29); 3150 __get_user(env->regs[30], &sc->regs.r30); 3151 __get_user(env->regs[31], &sc->regs.r31); 3152 __get_user(env->sregs[SR_PC], &sc->regs.pc); 3153 } 3154 3155 static abi_ulong get_sigframe(struct target_sigaction *ka, 3156 CPUState *env, int frame_size) 3157 { 3158 abi_ulong sp = env->regs[1]; 3159 3160 if ((ka->sa_flags & SA_ONSTACK) != 0 && !on_sig_stack(sp)) 3161 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 3162 3163 return ((sp - frame_size) & -8UL); 3164 } 3165 3166 static void setup_frame(int sig, struct target_sigaction *ka, 3167 target_sigset_t *set, CPUState *env) 3168 { 3169 struct target_signal_frame *frame; 3170 abi_ulong frame_addr; 3171 int err = 0; 3172 int i; 3173 3174 frame_addr = get_sigframe(ka, env, sizeof *frame); 3175 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 3176 goto badframe; 3177 3178 /* Save the mask. */ 3179 err |= __put_user(set->sig[0], &frame->sc.oldmask); 3180 if (err) 3181 goto badframe; 3182 3183 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 3184 if (__put_user(set->sig[i], &frame->extramask[i - 1])) 3185 goto badframe; 3186 } 3187 3188 setup_sigcontext(&frame->sc, env); 3189 3190 /* Set up to return from userspace. If provided, use a stub 3191 already in userspace. */ 3192 /* minus 8 is offset to cater for "rtsd r15,8" offset */ 3193 if (ka->sa_flags & TARGET_SA_RESTORER) { 3194 env->regs[15] = ((unsigned long)ka->sa_restorer)-8; 3195 } else { 3196 uint32_t t; 3197 /* Note, these encodings are _big endian_! */ 3198 /* addi r12, r0, __NR_sigreturn */ 3199 t = 0x31800000UL | TARGET_NR_sigreturn; 3200 err |= __put_user(t, frame->tramp + 0); 3201 /* brki r14, 0x8 */ 3202 t = 0xb9cc0008UL; 3203 err |= __put_user(t, frame->tramp + 1); 3204 3205 /* Return from sighandler will jump to the tramp. 3206 Negative 8 offset because return is rtsd r15, 8 */ 3207 env->regs[15] = ((unsigned long)frame->tramp) - 8; 3208 } 3209 3210 if (err) 3211 goto badframe; 3212 3213 /* Set up registers for signal handler */ 3214 env->regs[1] = (unsigned long) frame; 3215 /* Signal handler args: */ 3216 env->regs[5] = sig; /* Arg 0: signum */ 3217 env->regs[6] = (unsigned long) &frame->sc; /* arg 1: sigcontext */ 3218 3219 /* Offset of 4 to handle microblaze rtid r14, 0 */ 3220 env->sregs[SR_PC] = (unsigned long)ka->_sa_handler; 3221 3222 unlock_user_struct(frame, frame_addr, 1); 3223 return; 3224 badframe: 3225 unlock_user_struct(frame, frame_addr, 1); 3226 force_sig(TARGET_SIGSEGV); 3227 } 3228 3229 static void setup_rt_frame(int sig, struct target_sigaction *ka, 3230 target_siginfo_t *info, 3231 target_sigset_t *set, CPUState *env) 3232 { 3233 fprintf(stderr, "Microblaze setup_rt_frame: not implemented\n"); 3234 } 3235 3236 long do_sigreturn(CPUState *env) 3237 { 3238 struct target_signal_frame *frame; 3239 abi_ulong frame_addr; 3240 target_sigset_t target_set; 3241 sigset_t set; 3242 int i; 3243 3244 frame_addr = env->regs[R_SP]; 3245 /* Make sure the guest isn't playing games. */ 3246 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1)) 3247 goto badframe; 3248 3249 /* Restore blocked signals */ 3250 if (__get_user(target_set.sig[0], &frame->sc.oldmask)) 3251 goto badframe; 3252 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 3253 if (__get_user(target_set.sig[i], &frame->extramask[i - 1])) 3254 goto badframe; 3255 } 3256 target_to_host_sigset_internal(&set, &target_set); 3257 sigprocmask(SIG_SETMASK, &set, NULL); 3258 3259 restore_sigcontext(&frame->sc, env); 3260 /* We got here through a sigreturn syscall, our path back is via an 3261 rtb insn so setup r14 for that. */ 3262 env->regs[14] = env->sregs[SR_PC]; 3263 3264 unlock_user_struct(frame, frame_addr, 0); 3265 return env->regs[10]; 3266 badframe: 3267 unlock_user_struct(frame, frame_addr, 0); 3268 force_sig(TARGET_SIGSEGV); 3269 } 3270 3271 long do_rt_sigreturn(CPUState *env) 3272 { 3273 fprintf(stderr, "Microblaze do_rt_sigreturn: not implemented\n"); 3274 return -TARGET_ENOSYS; 3275 } 3276 3277 #elif defined(TARGET_CRIS) 3278 3279 struct target_sigcontext { 3280 struct target_pt_regs regs; /* needs to be first */ 3281 uint32_t oldmask; 3282 uint32_t usp; /* usp before stacking this gunk on it */ 3283 }; 3284 3285 /* Signal frames. */ 3286 struct target_signal_frame { 3287 struct target_sigcontext sc; 3288 uint32_t extramask[TARGET_NSIG_WORDS - 1]; 3289 uint8_t retcode[8]; /* Trampoline code. */ 3290 }; 3291 3292 struct rt_signal_frame { 3293 struct siginfo *pinfo; 3294 void *puc; 3295 struct siginfo info; 3296 struct ucontext uc; 3297 uint8_t retcode[8]; /* Trampoline code. */ 3298 }; 3299 3300 static void setup_sigcontext(struct target_sigcontext *sc, CPUState *env) 3301 { 3302 __put_user(env->regs[0], &sc->regs.r0); 3303 __put_user(env->regs[1], &sc->regs.r1); 3304 __put_user(env->regs[2], &sc->regs.r2); 3305 __put_user(env->regs[3], &sc->regs.r3); 3306 __put_user(env->regs[4], &sc->regs.r4); 3307 __put_user(env->regs[5], &sc->regs.r5); 3308 __put_user(env->regs[6], &sc->regs.r6); 3309 __put_user(env->regs[7], &sc->regs.r7); 3310 __put_user(env->regs[8], &sc->regs.r8); 3311 __put_user(env->regs[9], &sc->regs.r9); 3312 __put_user(env->regs[10], &sc->regs.r10); 3313 __put_user(env->regs[11], &sc->regs.r11); 3314 __put_user(env->regs[12], &sc->regs.r12); 3315 __put_user(env->regs[13], &sc->regs.r13); 3316 __put_user(env->regs[14], &sc->usp); 3317 __put_user(env->regs[15], &sc->regs.acr); 3318 __put_user(env->pregs[PR_MOF], &sc->regs.mof); 3319 __put_user(env->pregs[PR_SRP], &sc->regs.srp); 3320 __put_user(env->pc, &sc->regs.erp); 3321 } 3322 3323 static void restore_sigcontext(struct target_sigcontext *sc, CPUState *env) 3324 { 3325 __get_user(env->regs[0], &sc->regs.r0); 3326 __get_user(env->regs[1], &sc->regs.r1); 3327 __get_user(env->regs[2], &sc->regs.r2); 3328 __get_user(env->regs[3], &sc->regs.r3); 3329 __get_user(env->regs[4], &sc->regs.r4); 3330 __get_user(env->regs[5], &sc->regs.r5); 3331 __get_user(env->regs[6], &sc->regs.r6); 3332 __get_user(env->regs[7], &sc->regs.r7); 3333 __get_user(env->regs[8], &sc->regs.r8); 3334 __get_user(env->regs[9], &sc->regs.r9); 3335 __get_user(env->regs[10], &sc->regs.r10); 3336 __get_user(env->regs[11], &sc->regs.r11); 3337 __get_user(env->regs[12], &sc->regs.r12); 3338 __get_user(env->regs[13], &sc->regs.r13); 3339 __get_user(env->regs[14], &sc->usp); 3340 __get_user(env->regs[15], &sc->regs.acr); 3341 __get_user(env->pregs[PR_MOF], &sc->regs.mof); 3342 __get_user(env->pregs[PR_SRP], &sc->regs.srp); 3343 __get_user(env->pc, &sc->regs.erp); 3344 } 3345 3346 static abi_ulong get_sigframe(CPUState *env, int framesize) 3347 { 3348 abi_ulong sp; 3349 /* Align the stack downwards to 4. */ 3350 sp = (env->regs[R_SP] & ~3); 3351 return sp - framesize; 3352 } 3353 3354 static void setup_frame(int sig, struct target_sigaction *ka, 3355 target_sigset_t *set, CPUState *env) 3356 { 3357 struct target_signal_frame *frame; 3358 abi_ulong frame_addr; 3359 int err = 0; 3360 int i; 3361 3362 frame_addr = get_sigframe(env, sizeof *frame); 3363 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 3364 goto badframe; 3365 3366 /* 3367 * The CRIS signal return trampoline. A real linux/CRIS kernel doesn't 3368 * use this trampoline anymore but it sets it up for GDB. 3369 * In QEMU, using the trampoline simplifies things a bit so we use it. 3370 * 3371 * This is movu.w __NR_sigreturn, r9; break 13; 3372 */ 3373 err |= __put_user(0x9c5f, frame->retcode+0); 3374 err |= __put_user(TARGET_NR_sigreturn, 3375 frame->retcode+2); 3376 err |= __put_user(0xe93d, frame->retcode+4); 3377 3378 /* Save the mask. */ 3379 err |= __put_user(set->sig[0], &frame->sc.oldmask); 3380 if (err) 3381 goto badframe; 3382 3383 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 3384 if (__put_user(set->sig[i], &frame->extramask[i - 1])) 3385 goto badframe; 3386 } 3387 3388 setup_sigcontext(&frame->sc, env); 3389 3390 /* Move the stack and setup the arguments for the handler. */ 3391 env->regs[R_SP] = (uint32_t) (unsigned long) frame; 3392 env->regs[10] = sig; 3393 env->pc = (unsigned long) ka->_sa_handler; 3394 /* Link SRP so the guest returns through the trampoline. */ 3395 env->pregs[PR_SRP] = (uint32_t) (unsigned long) &frame->retcode[0]; 3396 3397 unlock_user_struct(frame, frame_addr, 1); 3398 return; 3399 badframe: 3400 unlock_user_struct(frame, frame_addr, 1); 3401 force_sig(TARGET_SIGSEGV); 3402 } 3403 3404 static void setup_rt_frame(int sig, struct target_sigaction *ka, 3405 target_siginfo_t *info, 3406 target_sigset_t *set, CPUState *env) 3407 { 3408 fprintf(stderr, "CRIS setup_rt_frame: not implemented\n"); 3409 } 3410 3411 long do_sigreturn(CPUState *env) 3412 { 3413 struct target_signal_frame *frame; 3414 abi_ulong frame_addr; 3415 target_sigset_t target_set; 3416 sigset_t set; 3417 int i; 3418 3419 frame_addr = env->regs[R_SP]; 3420 /* Make sure the guest isn't playing games. */ 3421 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1)) 3422 goto badframe; 3423 3424 /* Restore blocked signals */ 3425 if (__get_user(target_set.sig[0], &frame->sc.oldmask)) 3426 goto badframe; 3427 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 3428 if (__get_user(target_set.sig[i], &frame->extramask[i - 1])) 3429 goto badframe; 3430 } 3431 target_to_host_sigset_internal(&set, &target_set); 3432 sigprocmask(SIG_SETMASK, &set, NULL); 3433 3434 restore_sigcontext(&frame->sc, env); 3435 unlock_user_struct(frame, frame_addr, 0); 3436 return env->regs[10]; 3437 badframe: 3438 unlock_user_struct(frame, frame_addr, 0); 3439 force_sig(TARGET_SIGSEGV); 3440 } 3441 3442 long do_rt_sigreturn(CPUState *env) 3443 { 3444 fprintf(stderr, "CRIS do_rt_sigreturn: not implemented\n"); 3445 return -TARGET_ENOSYS; 3446 } 3447 3448 #elif defined(TARGET_PPC) && !defined(TARGET_PPC64) 3449 3450 /* FIXME: Many of the structures are defined for both PPC and PPC64, but 3451 the signal handling is different enough that we haven't implemented 3452 support for PPC64 yet. Hence the restriction above. 3453 3454 There are various #if'd blocks for code for TARGET_PPC64. These 3455 blocks should go away so that we can successfully run 32-bit and 3456 64-bit binaries on a QEMU configured for PPC64. */ 3457 3458 /* Size of dummy stack frame allocated when calling signal handler. 3459 See arch/powerpc/include/asm/ptrace.h. */ 3460 #if defined(TARGET_PPC64) 3461 #define SIGNAL_FRAMESIZE 128 3462 #else 3463 #define SIGNAL_FRAMESIZE 64 3464 #endif 3465 3466 /* See arch/powerpc/include/asm/sigcontext.h. */ 3467 struct target_sigcontext { 3468 target_ulong _unused[4]; 3469 int32_t signal; 3470 #if defined(TARGET_PPC64) 3471 int32_t pad0; 3472 #endif 3473 target_ulong handler; 3474 target_ulong oldmask; 3475 target_ulong regs; /* struct pt_regs __user * */ 3476 /* TODO: PPC64 includes extra bits here. */ 3477 }; 3478 3479 /* Indices for target_mcontext.mc_gregs, below. 3480 See arch/powerpc/include/asm/ptrace.h for details. */ 3481 enum { 3482 TARGET_PT_R0 = 0, 3483 TARGET_PT_R1 = 1, 3484 TARGET_PT_R2 = 2, 3485 TARGET_PT_R3 = 3, 3486 TARGET_PT_R4 = 4, 3487 TARGET_PT_R5 = 5, 3488 TARGET_PT_R6 = 6, 3489 TARGET_PT_R7 = 7, 3490 TARGET_PT_R8 = 8, 3491 TARGET_PT_R9 = 9, 3492 TARGET_PT_R10 = 10, 3493 TARGET_PT_R11 = 11, 3494 TARGET_PT_R12 = 12, 3495 TARGET_PT_R13 = 13, 3496 TARGET_PT_R14 = 14, 3497 TARGET_PT_R15 = 15, 3498 TARGET_PT_R16 = 16, 3499 TARGET_PT_R17 = 17, 3500 TARGET_PT_R18 = 18, 3501 TARGET_PT_R19 = 19, 3502 TARGET_PT_R20 = 20, 3503 TARGET_PT_R21 = 21, 3504 TARGET_PT_R22 = 22, 3505 TARGET_PT_R23 = 23, 3506 TARGET_PT_R24 = 24, 3507 TARGET_PT_R25 = 25, 3508 TARGET_PT_R26 = 26, 3509 TARGET_PT_R27 = 27, 3510 TARGET_PT_R28 = 28, 3511 TARGET_PT_R29 = 29, 3512 TARGET_PT_R30 = 30, 3513 TARGET_PT_R31 = 31, 3514 TARGET_PT_NIP = 32, 3515 TARGET_PT_MSR = 33, 3516 TARGET_PT_ORIG_R3 = 34, 3517 TARGET_PT_CTR = 35, 3518 TARGET_PT_LNK = 36, 3519 TARGET_PT_XER = 37, 3520 TARGET_PT_CCR = 38, 3521 /* Yes, there are two registers with #39. One is 64-bit only. */ 3522 TARGET_PT_MQ = 39, 3523 TARGET_PT_SOFTE = 39, 3524 TARGET_PT_TRAP = 40, 3525 TARGET_PT_DAR = 41, 3526 TARGET_PT_DSISR = 42, 3527 TARGET_PT_RESULT = 43, 3528 TARGET_PT_REGS_COUNT = 44 3529 }; 3530 3531 /* See arch/powerpc/include/asm/ucontext.h. Only used for 32-bit PPC; 3532 on 64-bit PPC, sigcontext and mcontext are one and the same. */ 3533 struct target_mcontext { 3534 target_ulong mc_gregs[48]; 3535 /* Includes fpscr. */ 3536 uint64_t mc_fregs[33]; 3537 target_ulong mc_pad[2]; 3538 /* We need to handle Altivec and SPE at the same time, which no 3539 kernel needs to do. Fortunately, the kernel defines this bit to 3540 be Altivec-register-large all the time, rather than trying to 3541 twiddle it based on the specific platform. */ 3542 union { 3543 /* SPE vector registers. One extra for SPEFSCR. */ 3544 uint32_t spe[33]; 3545 /* Altivec vector registers. The packing of VSCR and VRSAVE 3546 varies depending on whether we're PPC64 or not: PPC64 splits 3547 them apart; PPC32 stuffs them together. */ 3548 #if defined(TARGET_PPC64) 3549 #define QEMU_NVRREG 34 3550 #else 3551 #define QEMU_NVRREG 33 3552 #endif 3553 ppc_avr_t altivec[QEMU_NVRREG]; 3554 #undef QEMU_NVRREG 3555 } mc_vregs __attribute__((__aligned__(16))); 3556 }; 3557 3558 struct target_ucontext { 3559 target_ulong uc_flags; 3560 target_ulong uc_link; /* struct ucontext __user * */ 3561 struct target_sigaltstack uc_stack; 3562 #if !defined(TARGET_PPC64) 3563 int32_t uc_pad[7]; 3564 target_ulong uc_regs; /* struct mcontext __user * 3565 points to uc_mcontext field */ 3566 #endif 3567 target_sigset_t uc_sigmask; 3568 #if defined(TARGET_PPC64) 3569 target_sigset_t unused[15]; /* Allow for uc_sigmask growth */ 3570 struct target_sigcontext uc_mcontext; 3571 #else 3572 int32_t uc_maskext[30]; 3573 int32_t uc_pad2[3]; 3574 struct target_mcontext uc_mcontext; 3575 #endif 3576 }; 3577 3578 /* See arch/powerpc/kernel/signal_32.c. */ 3579 struct target_sigframe { 3580 struct target_sigcontext sctx; 3581 struct target_mcontext mctx; 3582 int32_t abigap[56]; 3583 }; 3584 3585 struct target_rt_sigframe { 3586 struct target_siginfo info; 3587 struct target_ucontext uc; 3588 int32_t abigap[56]; 3589 }; 3590 3591 /* We use the mc_pad field for the signal return trampoline. */ 3592 #define tramp mc_pad 3593 3594 /* See arch/powerpc/kernel/signal.c. */ 3595 static target_ulong get_sigframe(struct target_sigaction *ka, 3596 CPUState *env, 3597 int frame_size) 3598 { 3599 target_ulong oldsp, newsp; 3600 3601 oldsp = env->gpr[1]; 3602 3603 if ((ka->sa_flags & TARGET_SA_ONSTACK) && 3604 (sas_ss_flags(oldsp))) { 3605 oldsp = (target_sigaltstack_used.ss_sp 3606 + target_sigaltstack_used.ss_size); 3607 } 3608 3609 newsp = (oldsp - frame_size) & ~0xFUL; 3610 3611 return newsp; 3612 } 3613 3614 static int save_user_regs(CPUState *env, struct target_mcontext *frame, 3615 int sigret) 3616 { 3617 target_ulong msr = env->msr; 3618 int i; 3619 target_ulong ccr = 0; 3620 3621 /* In general, the kernel attempts to be intelligent about what it 3622 needs to save for Altivec/FP/SPE registers. We don't care that 3623 much, so we just go ahead and save everything. */ 3624 3625 /* Save general registers. */ 3626 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) { 3627 if (__put_user(env->gpr[i], &frame->mc_gregs[i])) { 3628 return 1; 3629 } 3630 } 3631 if (__put_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP]) 3632 || __put_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR]) 3633 || __put_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK]) 3634 || __put_user(env->xer, &frame->mc_gregs[TARGET_PT_XER])) 3635 return 1; 3636 3637 for (i = 0; i < ARRAY_SIZE(env->crf); i++) { 3638 ccr |= env->crf[i] << (32 - ((i + 1) * 4)); 3639 } 3640 if (__put_user(ccr, &frame->mc_gregs[TARGET_PT_CCR])) 3641 return 1; 3642 3643 /* Save Altivec registers if necessary. */ 3644 if (env->insns_flags & PPC_ALTIVEC) { 3645 for (i = 0; i < ARRAY_SIZE(env->avr); i++) { 3646 ppc_avr_t *avr = &env->avr[i]; 3647 ppc_avr_t *vreg = &frame->mc_vregs.altivec[i]; 3648 3649 if (__put_user(avr->u64[0], &vreg->u64[0]) || 3650 __put_user(avr->u64[1], &vreg->u64[1])) { 3651 return 1; 3652 } 3653 } 3654 /* Set MSR_VR in the saved MSR value to indicate that 3655 frame->mc_vregs contains valid data. */ 3656 msr |= MSR_VR; 3657 if (__put_user((uint32_t)env->spr[SPR_VRSAVE], 3658 &frame->mc_vregs.altivec[32].u32[3])) 3659 return 1; 3660 } 3661 3662 /* Save floating point registers. */ 3663 if (env->insns_flags & PPC_FLOAT) { 3664 for (i = 0; i < ARRAY_SIZE(env->fpr); i++) { 3665 if (__put_user(env->fpr[i], &frame->mc_fregs[i])) { 3666 return 1; 3667 } 3668 } 3669 if (__put_user((uint64_t) env->fpscr, &frame->mc_fregs[32])) 3670 return 1; 3671 } 3672 3673 /* Save SPE registers. The kernel only saves the high half. */ 3674 if (env->insns_flags & PPC_SPE) { 3675 #if defined(TARGET_PPC64) 3676 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) { 3677 if (__put_user(env->gpr[i] >> 32, &frame->mc_vregs.spe[i])) { 3678 return 1; 3679 } 3680 } 3681 #else 3682 for (i = 0; i < ARRAY_SIZE(env->gprh); i++) { 3683 if (__put_user(env->gprh[i], &frame->mc_vregs.spe[i])) { 3684 return 1; 3685 } 3686 } 3687 #endif 3688 /* Set MSR_SPE in the saved MSR value to indicate that 3689 frame->mc_vregs contains valid data. */ 3690 msr |= MSR_SPE; 3691 if (__put_user(env->spe_fscr, &frame->mc_vregs.spe[32])) 3692 return 1; 3693 } 3694 3695 /* Store MSR. */ 3696 if (__put_user(msr, &frame->mc_gregs[TARGET_PT_MSR])) 3697 return 1; 3698 3699 /* Set up the sigreturn trampoline: li r0,sigret; sc. */ 3700 if (sigret) { 3701 if (__put_user(0x38000000UL | sigret, &frame->tramp[0]) || 3702 __put_user(0x44000002UL, &frame->tramp[1])) { 3703 return 1; 3704 } 3705 } 3706 3707 return 0; 3708 } 3709 3710 static int restore_user_regs(CPUState *env, 3711 struct target_mcontext *frame, int sig) 3712 { 3713 target_ulong save_r2 = 0; 3714 target_ulong msr; 3715 target_ulong ccr; 3716 3717 int i; 3718 3719 if (!sig) { 3720 save_r2 = env->gpr[2]; 3721 } 3722 3723 /* Restore general registers. */ 3724 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) { 3725 if (__get_user(env->gpr[i], &frame->mc_gregs[i])) { 3726 return 1; 3727 } 3728 } 3729 if (__get_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP]) 3730 || __get_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR]) 3731 || __get_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK]) 3732 || __get_user(env->xer, &frame->mc_gregs[TARGET_PT_XER])) 3733 return 1; 3734 if (__get_user(ccr, &frame->mc_gregs[TARGET_PT_CCR])) 3735 return 1; 3736 3737 for (i = 0; i < ARRAY_SIZE(env->crf); i++) { 3738 env->crf[i] = (ccr >> (32 - ((i + 1) * 4))) & 0xf; 3739 } 3740 3741 if (!sig) { 3742 env->gpr[2] = save_r2; 3743 } 3744 /* Restore MSR. */ 3745 if (__get_user(msr, &frame->mc_gregs[TARGET_PT_MSR])) 3746 return 1; 3747 3748 /* If doing signal return, restore the previous little-endian mode. */ 3749 if (sig) 3750 env->msr = (env->msr & ~MSR_LE) | (msr & MSR_LE); 3751 3752 /* Restore Altivec registers if necessary. */ 3753 if (env->insns_flags & PPC_ALTIVEC) { 3754 for (i = 0; i < ARRAY_SIZE(env->avr); i++) { 3755 ppc_avr_t *avr = &env->avr[i]; 3756 ppc_avr_t *vreg = &frame->mc_vregs.altivec[i]; 3757 3758 if (__get_user(avr->u64[0], &vreg->u64[0]) || 3759 __get_user(avr->u64[1], &vreg->u64[1])) { 3760 return 1; 3761 } 3762 } 3763 /* Set MSR_VEC in the saved MSR value to indicate that 3764 frame->mc_vregs contains valid data. */ 3765 if (__get_user(env->spr[SPR_VRSAVE], 3766 (target_ulong *)(&frame->mc_vregs.altivec[32].u32[3]))) 3767 return 1; 3768 } 3769 3770 /* Restore floating point registers. */ 3771 if (env->insns_flags & PPC_FLOAT) { 3772 uint64_t fpscr; 3773 for (i = 0; i < ARRAY_SIZE(env->fpr); i++) { 3774 if (__get_user(env->fpr[i], &frame->mc_fregs[i])) { 3775 return 1; 3776 } 3777 } 3778 if (__get_user(fpscr, &frame->mc_fregs[32])) 3779 return 1; 3780 env->fpscr = (uint32_t) fpscr; 3781 } 3782 3783 /* Save SPE registers. The kernel only saves the high half. */ 3784 if (env->insns_flags & PPC_SPE) { 3785 #if defined(TARGET_PPC64) 3786 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) { 3787 uint32_t hi; 3788 3789 if (__get_user(hi, &frame->mc_vregs.spe[i])) { 3790 return 1; 3791 } 3792 env->gpr[i] = ((uint64_t)hi << 32) | ((uint32_t) env->gpr[i]); 3793 } 3794 #else 3795 for (i = 0; i < ARRAY_SIZE(env->gprh); i++) { 3796 if (__get_user(env->gprh[i], &frame->mc_vregs.spe[i])) { 3797 return 1; 3798 } 3799 } 3800 #endif 3801 if (__get_user(env->spe_fscr, &frame->mc_vregs.spe[32])) 3802 return 1; 3803 } 3804 3805 return 0; 3806 } 3807 3808 static void setup_frame(int sig, struct target_sigaction *ka, 3809 target_sigset_t *set, CPUState *env) 3810 { 3811 struct target_sigframe *frame; 3812 struct target_sigcontext *sc; 3813 target_ulong frame_addr, newsp; 3814 int err = 0; 3815 int signal; 3816 3817 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 3818 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1)) 3819 goto sigsegv; 3820 sc = &frame->sctx; 3821 3822 signal = current_exec_domain_sig(sig); 3823 3824 err |= __put_user(h2g(ka->_sa_handler), &sc->handler); 3825 err |= __put_user(set->sig[0], &sc->oldmask); 3826 #if defined(TARGET_PPC64) 3827 err |= __put_user(set->sig[0] >> 32, &sc->_unused[3]); 3828 #else 3829 err |= __put_user(set->sig[1], &sc->_unused[3]); 3830 #endif 3831 err |= __put_user(h2g(&frame->mctx), &sc->regs); 3832 err |= __put_user(sig, &sc->signal); 3833 3834 /* Save user regs. */ 3835 err |= save_user_regs(env, &frame->mctx, TARGET_NR_sigreturn); 3836 3837 /* The kernel checks for the presence of a VDSO here. We don't 3838 emulate a vdso, so use a sigreturn system call. */ 3839 env->lr = (target_ulong) h2g(frame->mctx.tramp); 3840 3841 /* Turn off all fp exceptions. */ 3842 env->fpscr = 0; 3843 3844 /* Create a stack frame for the caller of the handler. */ 3845 newsp = frame_addr - SIGNAL_FRAMESIZE; 3846 err |= __put_user(env->gpr[1], (target_ulong *)(uintptr_t) newsp); 3847 3848 if (err) 3849 goto sigsegv; 3850 3851 /* Set up registers for signal handler. */ 3852 env->gpr[1] = newsp; 3853 env->gpr[3] = signal; 3854 env->gpr[4] = (target_ulong) h2g(sc); 3855 env->nip = (target_ulong) ka->_sa_handler; 3856 /* Signal handlers are entered in big-endian mode. */ 3857 env->msr &= ~MSR_LE; 3858 3859 unlock_user_struct(frame, frame_addr, 1); 3860 return; 3861 3862 sigsegv: 3863 unlock_user_struct(frame, frame_addr, 1); 3864 if (logfile) 3865 fprintf (logfile, "segfaulting from setup_frame\n"); 3866 force_sig(TARGET_SIGSEGV); 3867 } 3868 3869 static void setup_rt_frame(int sig, struct target_sigaction *ka, 3870 target_siginfo_t *info, 3871 target_sigset_t *set, CPUState *env) 3872 { 3873 struct target_rt_sigframe *rt_sf; 3874 struct target_mcontext *frame; 3875 target_ulong rt_sf_addr, newsp = 0; 3876 int i, err = 0; 3877 int signal; 3878 3879 rt_sf_addr = get_sigframe(ka, env, sizeof(*rt_sf)); 3880 if (!lock_user_struct(VERIFY_WRITE, rt_sf, rt_sf_addr, 1)) 3881 goto sigsegv; 3882 3883 signal = current_exec_domain_sig(sig); 3884 3885 err |= copy_siginfo_to_user(&rt_sf->info, info); 3886 3887 err |= __put_user(0, &rt_sf->uc.uc_flags); 3888 err |= __put_user(0, &rt_sf->uc.uc_link); 3889 err |= __put_user((target_ulong)target_sigaltstack_used.ss_sp, 3890 &rt_sf->uc.uc_stack.ss_sp); 3891 err |= __put_user(sas_ss_flags(env->gpr[1]), 3892 &rt_sf->uc.uc_stack.ss_flags); 3893 err |= __put_user(target_sigaltstack_used.ss_size, 3894 &rt_sf->uc.uc_stack.ss_size); 3895 err |= __put_user(h2g (&rt_sf->uc.uc_mcontext), 3896 &rt_sf->uc.uc_regs); 3897 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 3898 err |= __put_user(set->sig[i], &rt_sf->uc.uc_sigmask.sig[i]); 3899 } 3900 3901 frame = &rt_sf->uc.uc_mcontext; 3902 err |= save_user_regs(env, frame, TARGET_NR_rt_sigreturn); 3903 3904 /* The kernel checks for the presence of a VDSO here. We don't 3905 emulate a vdso, so use a sigreturn system call. */ 3906 env->lr = (target_ulong) h2g(frame->tramp); 3907 3908 /* Turn off all fp exceptions. */ 3909 env->fpscr = 0; 3910 3911 /* Create a stack frame for the caller of the handler. */ 3912 newsp = rt_sf_addr - (SIGNAL_FRAMESIZE + 16); 3913 err |= __put_user(env->gpr[1], (target_ulong *)(uintptr_t) newsp); 3914 3915 if (err) 3916 goto sigsegv; 3917 3918 /* Set up registers for signal handler. */ 3919 env->gpr[1] = newsp; 3920 env->gpr[3] = (target_ulong) signal; 3921 env->gpr[4] = (target_ulong) h2g(&rt_sf->info); 3922 env->gpr[5] = (target_ulong) h2g(&rt_sf->uc); 3923 env->gpr[6] = (target_ulong) h2g(rt_sf); 3924 env->nip = (target_ulong) ka->_sa_handler; 3925 /* Signal handlers are entered in big-endian mode. */ 3926 env->msr &= ~MSR_LE; 3927 3928 unlock_user_struct(rt_sf, rt_sf_addr, 1); 3929 return; 3930 3931 sigsegv: 3932 unlock_user_struct(rt_sf, rt_sf_addr, 1); 3933 if (logfile) 3934 fprintf (logfile, "segfaulting from setup_rt_frame\n"); 3935 force_sig(TARGET_SIGSEGV); 3936 3937 } 3938 3939 long do_sigreturn(CPUState *env) 3940 { 3941 struct target_sigcontext *sc = NULL; 3942 struct target_mcontext *sr = NULL; 3943 target_ulong sr_addr, sc_addr; 3944 sigset_t blocked; 3945 target_sigset_t set; 3946 3947 sc_addr = env->gpr[1] + SIGNAL_FRAMESIZE; 3948 if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1)) 3949 goto sigsegv; 3950 3951 #if defined(TARGET_PPC64) 3952 set.sig[0] = sc->oldmask + ((long)(sc->_unused[3]) << 32); 3953 #else 3954 if(__get_user(set.sig[0], &sc->oldmask) || 3955 __get_user(set.sig[1], &sc->_unused[3])) 3956 goto sigsegv; 3957 #endif 3958 target_to_host_sigset_internal(&blocked, &set); 3959 sigprocmask(SIG_SETMASK, &blocked, NULL); 3960 3961 if (__get_user(sr_addr, &sc->regs)) 3962 goto sigsegv; 3963 if (!lock_user_struct(VERIFY_READ, sr, sr_addr, 1)) 3964 goto sigsegv; 3965 if (restore_user_regs(env, sr, 1)) 3966 goto sigsegv; 3967 3968 unlock_user_struct(sr, sr_addr, 1); 3969 unlock_user_struct(sc, sc_addr, 1); 3970 return -TARGET_QEMU_ESIGRETURN; 3971 3972 sigsegv: 3973 unlock_user_struct(sr, sr_addr, 1); 3974 unlock_user_struct(sc, sc_addr, 1); 3975 if (logfile) 3976 fprintf (logfile, "segfaulting from do_sigreturn\n"); 3977 force_sig(TARGET_SIGSEGV); 3978 return 0; 3979 } 3980 3981 /* See arch/powerpc/kernel/signal_32.c. */ 3982 static int do_setcontext(struct target_ucontext *ucp, CPUState *env, int sig) 3983 { 3984 struct target_mcontext *mcp; 3985 target_ulong mcp_addr; 3986 sigset_t blocked; 3987 target_sigset_t set; 3988 3989 if (copy_from_user(&set, h2g(ucp) + offsetof(struct target_ucontext, uc_sigmask), 3990 sizeof (set))) 3991 return 1; 3992 3993 #if defined(TARGET_PPC64) 3994 fprintf (stderr, "do_setcontext: not implemented\n"); 3995 return 0; 3996 #else 3997 if (__get_user(mcp_addr, &ucp->uc_regs)) 3998 return 1; 3999 4000 if (!lock_user_struct(VERIFY_READ, mcp, mcp_addr, 1)) 4001 return 1; 4002 4003 target_to_host_sigset_internal(&blocked, &set); 4004 sigprocmask(SIG_SETMASK, &blocked, NULL); 4005 if (restore_user_regs(env, mcp, sig)) 4006 goto sigsegv; 4007 4008 unlock_user_struct(mcp, mcp_addr, 1); 4009 return 0; 4010 4011 sigsegv: 4012 unlock_user_struct(mcp, mcp_addr, 1); 4013 return 1; 4014 #endif 4015 } 4016 4017 long do_rt_sigreturn(CPUState *env) 4018 { 4019 struct target_rt_sigframe *rt_sf = NULL; 4020 target_ulong rt_sf_addr; 4021 4022 rt_sf_addr = env->gpr[1] + SIGNAL_FRAMESIZE + 16; 4023 if (!lock_user_struct(VERIFY_READ, rt_sf, rt_sf_addr, 1)) 4024 goto sigsegv; 4025 4026 if (do_setcontext(&rt_sf->uc, env, 1)) 4027 goto sigsegv; 4028 4029 do_sigaltstack(rt_sf_addr 4030 + offsetof(struct target_rt_sigframe, uc.uc_stack), 4031 0, env->gpr[1]); 4032 4033 unlock_user_struct(rt_sf, rt_sf_addr, 1); 4034 return -TARGET_QEMU_ESIGRETURN; 4035 4036 sigsegv: 4037 unlock_user_struct(rt_sf, rt_sf_addr, 1); 4038 if (logfile) 4039 fprintf (logfile, "segfaulting from do_rt_sigreturn\n"); 4040 force_sig(TARGET_SIGSEGV); 4041 return 0; 4042 } 4043 4044 #elif defined(TARGET_M68K) 4045 4046 struct target_sigcontext { 4047 abi_ulong sc_mask; 4048 abi_ulong sc_usp; 4049 abi_ulong sc_d0; 4050 abi_ulong sc_d1; 4051 abi_ulong sc_a0; 4052 abi_ulong sc_a1; 4053 unsigned short sc_sr; 4054 abi_ulong sc_pc; 4055 }; 4056 4057 struct target_sigframe 4058 { 4059 abi_ulong pretcode; 4060 int sig; 4061 int code; 4062 abi_ulong psc; 4063 char retcode[8]; 4064 abi_ulong extramask[TARGET_NSIG_WORDS-1]; 4065 struct target_sigcontext sc; 4066 }; 4067 4068 typedef int target_greg_t; 4069 #define TARGET_NGREG 18 4070 typedef target_greg_t target_gregset_t[TARGET_NGREG]; 4071 4072 typedef struct target_fpregset { 4073 int f_fpcntl[3]; 4074 int f_fpregs[8*3]; 4075 } target_fpregset_t; 4076 4077 struct target_mcontext { 4078 int version; 4079 target_gregset_t gregs; 4080 target_fpregset_t fpregs; 4081 }; 4082 4083 #define TARGET_MCONTEXT_VERSION 2 4084 4085 struct target_ucontext { 4086 abi_ulong uc_flags; 4087 abi_ulong uc_link; 4088 target_stack_t uc_stack; 4089 struct target_mcontext uc_mcontext; 4090 abi_long uc_filler[80]; 4091 target_sigset_t uc_sigmask; 4092 }; 4093 4094 struct target_rt_sigframe 4095 { 4096 abi_ulong pretcode; 4097 int sig; 4098 abi_ulong pinfo; 4099 abi_ulong puc; 4100 char retcode[8]; 4101 struct target_siginfo info; 4102 struct target_ucontext uc; 4103 }; 4104 4105 static int 4106 setup_sigcontext(struct target_sigcontext *sc, CPUState *env, abi_ulong mask) 4107 { 4108 int err = 0; 4109 4110 err |= __put_user(mask, &sc->sc_mask); 4111 err |= __put_user(env->aregs[7], &sc->sc_usp); 4112 err |= __put_user(env->dregs[0], &sc->sc_d0); 4113 err |= __put_user(env->dregs[1], &sc->sc_d1); 4114 err |= __put_user(env->aregs[0], &sc->sc_a0); 4115 err |= __put_user(env->aregs[1], &sc->sc_a1); 4116 err |= __put_user(env->sr, &sc->sc_sr); 4117 err |= __put_user(env->pc, &sc->sc_pc); 4118 4119 return err; 4120 } 4121 4122 static int 4123 restore_sigcontext(CPUState *env, struct target_sigcontext *sc, int *pd0) 4124 { 4125 int err = 0; 4126 int temp; 4127 4128 err |= __get_user(env->aregs[7], &sc->sc_usp); 4129 err |= __get_user(env->dregs[1], &sc->sc_d1); 4130 err |= __get_user(env->aregs[0], &sc->sc_a0); 4131 err |= __get_user(env->aregs[1], &sc->sc_a1); 4132 err |= __get_user(env->pc, &sc->sc_pc); 4133 err |= __get_user(temp, &sc->sc_sr); 4134 env->sr = (env->sr & 0xff00) | (temp & 0xff); 4135 4136 *pd0 = tswapl(sc->sc_d0); 4137 4138 return err; 4139 } 4140 4141 /* 4142 * Determine which stack to use.. 4143 */ 4144 static inline abi_ulong 4145 get_sigframe(struct target_sigaction *ka, CPUState *regs, size_t frame_size) 4146 { 4147 unsigned long sp; 4148 4149 sp = regs->aregs[7]; 4150 4151 /* This is the X/Open sanctioned signal stack switching. */ 4152 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) { 4153 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 4154 } 4155 4156 return ((sp - frame_size) & -8UL); 4157 } 4158 4159 static void setup_frame(int sig, struct target_sigaction *ka, 4160 target_sigset_t *set, CPUState *env) 4161 { 4162 struct target_sigframe *frame; 4163 abi_ulong frame_addr; 4164 abi_ulong retcode_addr; 4165 abi_ulong sc_addr; 4166 int err = 0; 4167 int i; 4168 4169 frame_addr = get_sigframe(ka, env, sizeof *frame); 4170 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 4171 goto give_sigsegv; 4172 4173 err |= __put_user(sig, &frame->sig); 4174 4175 sc_addr = frame_addr + offsetof(struct target_sigframe, sc); 4176 err |= __put_user(sc_addr, &frame->psc); 4177 4178 err |= setup_sigcontext(&frame->sc, env, set->sig[0]); 4179 if (err) 4180 goto give_sigsegv; 4181 4182 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 4183 if (__put_user(set->sig[i], &frame->extramask[i - 1])) 4184 goto give_sigsegv; 4185 } 4186 4187 /* Set up to return from userspace. */ 4188 4189 retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode); 4190 err |= __put_user(retcode_addr, &frame->pretcode); 4191 4192 /* moveq #,d0; trap #0 */ 4193 4194 err |= __put_user(0x70004e40 + (TARGET_NR_sigreturn << 16), 4195 (long *)(frame->retcode)); 4196 4197 if (err) 4198 goto give_sigsegv; 4199 4200 /* Set up to return from userspace */ 4201 4202 env->aregs[7] = frame_addr; 4203 env->pc = ka->_sa_handler; 4204 4205 unlock_user_struct(frame, frame_addr, 1); 4206 return; 4207 4208 give_sigsegv: 4209 unlock_user_struct(frame, frame_addr, 1); 4210 force_sig(TARGET_SIGSEGV); 4211 } 4212 4213 static inline int target_rt_setup_ucontext(struct target_ucontext *uc, 4214 CPUState *env) 4215 { 4216 target_greg_t *gregs = uc->uc_mcontext.gregs; 4217 int err; 4218 4219 err = __put_user(TARGET_MCONTEXT_VERSION, &uc->uc_mcontext.version); 4220 err |= __put_user(env->dregs[0], &gregs[0]); 4221 err |= __put_user(env->dregs[1], &gregs[1]); 4222 err |= __put_user(env->dregs[2], &gregs[2]); 4223 err |= __put_user(env->dregs[3], &gregs[3]); 4224 err |= __put_user(env->dregs[4], &gregs[4]); 4225 err |= __put_user(env->dregs[5], &gregs[5]); 4226 err |= __put_user(env->dregs[6], &gregs[6]); 4227 err |= __put_user(env->dregs[7], &gregs[7]); 4228 err |= __put_user(env->aregs[0], &gregs[8]); 4229 err |= __put_user(env->aregs[1], &gregs[9]); 4230 err |= __put_user(env->aregs[2], &gregs[10]); 4231 err |= __put_user(env->aregs[3], &gregs[11]); 4232 err |= __put_user(env->aregs[4], &gregs[12]); 4233 err |= __put_user(env->aregs[5], &gregs[13]); 4234 err |= __put_user(env->aregs[6], &gregs[14]); 4235 err |= __put_user(env->aregs[7], &gregs[15]); 4236 err |= __put_user(env->pc, &gregs[16]); 4237 err |= __put_user(env->sr, &gregs[17]); 4238 4239 return err; 4240 } 4241 4242 static inline int target_rt_restore_ucontext(CPUState *env, 4243 struct target_ucontext *uc, 4244 int *pd0) 4245 { 4246 int temp; 4247 int err; 4248 target_greg_t *gregs = uc->uc_mcontext.gregs; 4249 4250 err = __get_user(temp, &uc->uc_mcontext.version); 4251 if (temp != TARGET_MCONTEXT_VERSION) 4252 goto badframe; 4253 4254 /* restore passed registers */ 4255 err |= __get_user(env->dregs[0], &gregs[0]); 4256 err |= __get_user(env->dregs[1], &gregs[1]); 4257 err |= __get_user(env->dregs[2], &gregs[2]); 4258 err |= __get_user(env->dregs[3], &gregs[3]); 4259 err |= __get_user(env->dregs[4], &gregs[4]); 4260 err |= __get_user(env->dregs[5], &gregs[5]); 4261 err |= __get_user(env->dregs[6], &gregs[6]); 4262 err |= __get_user(env->dregs[7], &gregs[7]); 4263 err |= __get_user(env->aregs[0], &gregs[8]); 4264 err |= __get_user(env->aregs[1], &gregs[9]); 4265 err |= __get_user(env->aregs[2], &gregs[10]); 4266 err |= __get_user(env->aregs[3], &gregs[11]); 4267 err |= __get_user(env->aregs[4], &gregs[12]); 4268 err |= __get_user(env->aregs[5], &gregs[13]); 4269 err |= __get_user(env->aregs[6], &gregs[14]); 4270 err |= __get_user(env->aregs[7], &gregs[15]); 4271 err |= __get_user(env->pc, &gregs[16]); 4272 err |= __get_user(temp, &gregs[17]); 4273 env->sr = (env->sr & 0xff00) | (temp & 0xff); 4274 4275 *pd0 = env->dregs[0]; 4276 return err; 4277 4278 badframe: 4279 return 1; 4280 } 4281 4282 static void setup_rt_frame(int sig, struct target_sigaction *ka, 4283 target_siginfo_t *info, 4284 target_sigset_t *set, CPUState *env) 4285 { 4286 struct target_rt_sigframe *frame; 4287 abi_ulong frame_addr; 4288 abi_ulong retcode_addr; 4289 abi_ulong info_addr; 4290 abi_ulong uc_addr; 4291 int err = 0; 4292 int i; 4293 4294 frame_addr = get_sigframe(ka, env, sizeof *frame); 4295 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 4296 goto give_sigsegv; 4297 4298 err |= __put_user(sig, &frame->sig); 4299 4300 info_addr = frame_addr + offsetof(struct target_rt_sigframe, info); 4301 err |= __put_user(info_addr, &frame->pinfo); 4302 4303 uc_addr = frame_addr + offsetof(struct target_rt_sigframe, uc); 4304 err |= __put_user(uc_addr, &frame->puc); 4305 4306 err |= copy_siginfo_to_user(&frame->info, info); 4307 4308 /* Create the ucontext */ 4309 4310 err |= __put_user(0, &frame->uc.uc_flags); 4311 err |= __put_user(0, &frame->uc.uc_link); 4312 err |= __put_user(target_sigaltstack_used.ss_sp, 4313 &frame->uc.uc_stack.ss_sp); 4314 err |= __put_user(sas_ss_flags(env->aregs[7]), 4315 &frame->uc.uc_stack.ss_flags); 4316 err |= __put_user(target_sigaltstack_used.ss_size, 4317 &frame->uc.uc_stack.ss_size); 4318 err |= target_rt_setup_ucontext(&frame->uc, env); 4319 4320 if (err) 4321 goto give_sigsegv; 4322 4323 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 4324 if (__put_user(set->sig[i], &frame->uc.uc_sigmask.sig[i])) 4325 goto give_sigsegv; 4326 } 4327 4328 /* Set up to return from userspace. */ 4329 4330 retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode); 4331 err |= __put_user(retcode_addr, &frame->pretcode); 4332 4333 /* moveq #,d0; notb d0; trap #0 */ 4334 4335 err |= __put_user(0x70004600 + ((TARGET_NR_rt_sigreturn ^ 0xff) << 16), 4336 (long *)(frame->retcode + 0)); 4337 err |= __put_user(0x4e40, (short *)(frame->retcode + 4)); 4338 4339 if (err) 4340 goto give_sigsegv; 4341 4342 /* Set up to return from userspace */ 4343 4344 env->aregs[7] = frame_addr; 4345 env->pc = ka->_sa_handler; 4346 4347 unlock_user_struct(frame, frame_addr, 1); 4348 return; 4349 4350 give_sigsegv: 4351 unlock_user_struct(frame, frame_addr, 1); 4352 force_sig(TARGET_SIGSEGV); 4353 } 4354 4355 long do_sigreturn(CPUState *env) 4356 { 4357 struct target_sigframe *frame; 4358 abi_ulong frame_addr = env->aregs[7] - 4; 4359 target_sigset_t target_set; 4360 sigset_t set; 4361 int d0, i; 4362 4363 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 4364 goto badframe; 4365 4366 /* set blocked signals */ 4367 4368 if (__get_user(target_set.sig[0], &frame->sc.sc_mask)) 4369 goto badframe; 4370 4371 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 4372 if (__get_user(target_set.sig[i], &frame->extramask[i - 1])) 4373 goto badframe; 4374 } 4375 4376 target_to_host_sigset_internal(&set, &target_set); 4377 sigprocmask(SIG_SETMASK, &set, NULL); 4378 4379 /* restore registers */ 4380 4381 if (restore_sigcontext(env, &frame->sc, &d0)) 4382 goto badframe; 4383 4384 unlock_user_struct(frame, frame_addr, 0); 4385 return d0; 4386 4387 badframe: 4388 unlock_user_struct(frame, frame_addr, 0); 4389 force_sig(TARGET_SIGSEGV); 4390 return 0; 4391 } 4392 4393 long do_rt_sigreturn(CPUState *env) 4394 { 4395 struct target_rt_sigframe *frame; 4396 abi_ulong frame_addr = env->aregs[7] - 4; 4397 target_sigset_t target_set; 4398 sigset_t set; 4399 int d0; 4400 4401 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 4402 goto badframe; 4403 4404 target_to_host_sigset_internal(&set, &target_set); 4405 sigprocmask(SIG_SETMASK, &set, NULL); 4406 4407 /* restore registers */ 4408 4409 if (target_rt_restore_ucontext(env, &frame->uc, &d0)) 4410 goto badframe; 4411 4412 if (do_sigaltstack(frame_addr + 4413 offsetof(struct target_rt_sigframe, uc.uc_stack), 4414 0, get_sp_from_cpustate(env)) == -EFAULT) 4415 goto badframe; 4416 4417 unlock_user_struct(frame, frame_addr, 0); 4418 return d0; 4419 4420 badframe: 4421 unlock_user_struct(frame, frame_addr, 0); 4422 force_sig(TARGET_SIGSEGV); 4423 return 0; 4424 } 4425 4426 #elif defined(TARGET_ALPHA) 4427 4428 struct target_sigcontext { 4429 abi_long sc_onstack; 4430 abi_long sc_mask; 4431 abi_long sc_pc; 4432 abi_long sc_ps; 4433 abi_long sc_regs[32]; 4434 abi_long sc_ownedfp; 4435 abi_long sc_fpregs[32]; 4436 abi_ulong sc_fpcr; 4437 abi_ulong sc_fp_control; 4438 abi_ulong sc_reserved1; 4439 abi_ulong sc_reserved2; 4440 abi_ulong sc_ssize; 4441 abi_ulong sc_sbase; 4442 abi_ulong sc_traparg_a0; 4443 abi_ulong sc_traparg_a1; 4444 abi_ulong sc_traparg_a2; 4445 abi_ulong sc_fp_trap_pc; 4446 abi_ulong sc_fp_trigger_sum; 4447 abi_ulong sc_fp_trigger_inst; 4448 }; 4449 4450 struct target_ucontext { 4451 abi_ulong uc_flags; 4452 abi_ulong uc_link; 4453 abi_ulong uc_osf_sigmask; 4454 target_stack_t uc_stack; 4455 struct target_sigcontext uc_mcontext; 4456 target_sigset_t uc_sigmask; 4457 }; 4458 4459 struct target_sigframe { 4460 struct target_sigcontext sc; 4461 unsigned int retcode[3]; 4462 }; 4463 4464 struct target_rt_sigframe { 4465 target_siginfo_t info; 4466 struct target_ucontext uc; 4467 unsigned int retcode[3]; 4468 }; 4469 4470 #define INSN_MOV_R30_R16 0x47fe0410 4471 #define INSN_LDI_R0 0x201f0000 4472 #define INSN_CALLSYS 0x00000083 4473 4474 static int setup_sigcontext(struct target_sigcontext *sc, CPUState *env, 4475 abi_ulong frame_addr, target_sigset_t *set) 4476 { 4477 int i, err = 0; 4478 4479 err |= __put_user(on_sig_stack(frame_addr), &sc->sc_onstack); 4480 err |= __put_user(set->sig[0], &sc->sc_mask); 4481 err |= __put_user(env->pc, &sc->sc_pc); 4482 err |= __put_user(8, &sc->sc_ps); 4483 4484 for (i = 0; i < 31; ++i) { 4485 err |= __put_user(env->ir[i], &sc->sc_regs[i]); 4486 } 4487 err |= __put_user(0, &sc->sc_regs[31]); 4488 4489 for (i = 0; i < 31; ++i) { 4490 err |= __put_user(env->fir[i], &sc->sc_fpregs[i]); 4491 } 4492 err |= __put_user(0, &sc->sc_fpregs[31]); 4493 err |= __put_user(cpu_alpha_load_fpcr(env), &sc->sc_fpcr); 4494 4495 err |= __put_user(0, &sc->sc_traparg_a0); /* FIXME */ 4496 err |= __put_user(0, &sc->sc_traparg_a1); /* FIXME */ 4497 err |= __put_user(0, &sc->sc_traparg_a2); /* FIXME */ 4498 4499 return err; 4500 } 4501 4502 static int restore_sigcontext(CPUState *env, struct target_sigcontext *sc) 4503 { 4504 uint64_t fpcr; 4505 int i, err = 0; 4506 4507 err |= __get_user(env->pc, &sc->sc_pc); 4508 4509 for (i = 0; i < 31; ++i) { 4510 err |= __get_user(env->ir[i], &sc->sc_regs[i]); 4511 } 4512 for (i = 0; i < 31; ++i) { 4513 err |= __get_user(env->fir[i], &sc->sc_fpregs[i]); 4514 } 4515 4516 err |= __get_user(fpcr, &sc->sc_fpcr); 4517 cpu_alpha_store_fpcr(env, fpcr); 4518 4519 return err; 4520 } 4521 4522 static inline abi_ulong get_sigframe(struct target_sigaction *sa, 4523 CPUState *env, unsigned long framesize) 4524 { 4525 abi_ulong sp = env->ir[IR_SP]; 4526 4527 /* This is the X/Open sanctioned signal stack switching. */ 4528 if ((sa->sa_flags & TARGET_SA_ONSTACK) != 0 && !sas_ss_flags(sp)) { 4529 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 4530 } 4531 return (sp - framesize) & -32; 4532 } 4533 4534 static void setup_frame(int sig, struct target_sigaction *ka, 4535 target_sigset_t *set, CPUState *env) 4536 { 4537 abi_ulong frame_addr, r26; 4538 struct target_sigframe *frame; 4539 int err = 0; 4540 4541 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 4542 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 4543 goto give_sigsegv; 4544 } 4545 4546 err |= setup_sigcontext(&frame->sc, env, frame_addr, set); 4547 4548 if (ka->sa_restorer) { 4549 r26 = ka->sa_restorer; 4550 } else { 4551 err |= __put_user(INSN_MOV_R30_R16, &frame->retcode[0]); 4552 err |= __put_user(INSN_LDI_R0 + TARGET_NR_sigreturn, 4553 &frame->retcode[1]); 4554 err |= __put_user(INSN_CALLSYS, &frame->retcode[2]); 4555 /* imb() */ 4556 r26 = frame_addr; 4557 } 4558 4559 unlock_user_struct(frame, frame_addr, 1); 4560 4561 if (err) { 4562 give_sigsegv: 4563 if (sig == TARGET_SIGSEGV) { 4564 ka->_sa_handler = TARGET_SIG_DFL; 4565 } 4566 force_sig(TARGET_SIGSEGV); 4567 } 4568 4569 env->ir[IR_RA] = r26; 4570 env->ir[IR_PV] = env->pc = ka->_sa_handler; 4571 env->ir[IR_A0] = sig; 4572 env->ir[IR_A1] = 0; 4573 env->ir[IR_A2] = frame_addr + offsetof(struct target_sigframe, sc); 4574 env->ir[IR_SP] = frame_addr; 4575 } 4576 4577 static void setup_rt_frame(int sig, struct target_sigaction *ka, 4578 target_siginfo_t *info, 4579 target_sigset_t *set, CPUState *env) 4580 { 4581 abi_ulong frame_addr, r26; 4582 struct target_rt_sigframe *frame; 4583 int i, err = 0; 4584 4585 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 4586 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 4587 goto give_sigsegv; 4588 } 4589 4590 err |= copy_siginfo_to_user(&frame->info, info); 4591 4592 err |= __put_user(0, &frame->uc.uc_flags); 4593 err |= __put_user(0, &frame->uc.uc_link); 4594 err |= __put_user(set->sig[0], &frame->uc.uc_osf_sigmask); 4595 err |= __put_user(target_sigaltstack_used.ss_sp, 4596 &frame->uc.uc_stack.ss_sp); 4597 err |= __put_user(sas_ss_flags(env->ir[IR_SP]), 4598 &frame->uc.uc_stack.ss_flags); 4599 err |= __put_user(target_sigaltstack_used.ss_size, 4600 &frame->uc.uc_stack.ss_size); 4601 err |= setup_sigcontext(&frame->uc.uc_mcontext, env, frame_addr, set); 4602 for (i = 0; i < TARGET_NSIG_WORDS; ++i) { 4603 err |= __put_user(set->sig[i], &frame->uc.uc_sigmask.sig[i]); 4604 } 4605 4606 if (ka->sa_restorer) { 4607 r26 = ka->sa_restorer; 4608 } else { 4609 err |= __put_user(INSN_MOV_R30_R16, &frame->retcode[0]); 4610 err |= __put_user(INSN_LDI_R0 + TARGET_NR_rt_sigreturn, 4611 &frame->retcode[1]); 4612 err |= __put_user(INSN_CALLSYS, &frame->retcode[2]); 4613 /* imb(); */ 4614 r26 = frame_addr; 4615 } 4616 4617 if (err) { 4618 give_sigsegv: 4619 if (sig == TARGET_SIGSEGV) { 4620 ka->_sa_handler = TARGET_SIG_DFL; 4621 } 4622 force_sig(TARGET_SIGSEGV); 4623 } 4624 4625 env->ir[IR_RA] = r26; 4626 env->ir[IR_PV] = env->pc = ka->_sa_handler; 4627 env->ir[IR_A0] = sig; 4628 env->ir[IR_A1] = frame_addr + offsetof(struct target_rt_sigframe, info); 4629 env->ir[IR_A2] = frame_addr + offsetof(struct target_rt_sigframe, uc); 4630 env->ir[IR_SP] = frame_addr; 4631 } 4632 4633 long do_sigreturn(CPUState *env) 4634 { 4635 struct target_sigcontext *sc; 4636 abi_ulong sc_addr = env->ir[IR_A0]; 4637 target_sigset_t target_set; 4638 sigset_t set; 4639 4640 if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1)) { 4641 goto badframe; 4642 } 4643 4644 target_sigemptyset(&target_set); 4645 if (__get_user(target_set.sig[0], &sc->sc_mask)) { 4646 goto badframe; 4647 } 4648 4649 target_to_host_sigset_internal(&set, &target_set); 4650 sigprocmask(SIG_SETMASK, &set, NULL); 4651 4652 if (restore_sigcontext(env, sc)) { 4653 goto badframe; 4654 } 4655 unlock_user_struct(sc, sc_addr, 0); 4656 return env->ir[IR_V0]; 4657 4658 badframe: 4659 unlock_user_struct(sc, sc_addr, 0); 4660 force_sig(TARGET_SIGSEGV); 4661 } 4662 4663 long do_rt_sigreturn(CPUState *env) 4664 { 4665 abi_ulong frame_addr = env->ir[IR_A0]; 4666 struct target_rt_sigframe *frame; 4667 sigset_t set; 4668 4669 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) { 4670 goto badframe; 4671 } 4672 target_to_host_sigset(&set, &frame->uc.uc_sigmask); 4673 sigprocmask(SIG_SETMASK, &set, NULL); 4674 4675 if (restore_sigcontext(env, &frame->uc.uc_mcontext)) { 4676 goto badframe; 4677 } 4678 if (do_sigaltstack(frame_addr + offsetof(struct target_rt_sigframe, 4679 uc.uc_stack), 4680 0, env->ir[IR_SP]) == -EFAULT) { 4681 goto badframe; 4682 } 4683 4684 unlock_user_struct(frame, frame_addr, 0); 4685 return env->ir[IR_V0]; 4686 4687 4688 badframe: 4689 unlock_user_struct(frame, frame_addr, 0); 4690 force_sig(TARGET_SIGSEGV); 4691 } 4692 4693 #else 4694 4695 static void setup_frame(int sig, struct target_sigaction *ka, 4696 target_sigset_t *set, CPUState *env) 4697 { 4698 fprintf(stderr, "setup_frame: not implemented\n"); 4699 } 4700 4701 static void setup_rt_frame(int sig, struct target_sigaction *ka, 4702 target_siginfo_t *info, 4703 target_sigset_t *set, CPUState *env) 4704 { 4705 fprintf(stderr, "setup_rt_frame: not implemented\n"); 4706 } 4707 4708 long do_sigreturn(CPUState *env) 4709 { 4710 fprintf(stderr, "do_sigreturn: not implemented\n"); 4711 return -TARGET_ENOSYS; 4712 } 4713 4714 long do_rt_sigreturn(CPUState *env) 4715 { 4716 fprintf(stderr, "do_rt_sigreturn: not implemented\n"); 4717 return -TARGET_ENOSYS; 4718 } 4719 4720 #endif 4721 4722 void process_pending_signals(CPUState *cpu_env) 4723 { 4724 int sig; 4725 abi_ulong handler; 4726 sigset_t set, old_set; 4727 target_sigset_t target_old_set; 4728 struct emulated_sigtable *k; 4729 struct target_sigaction *sa; 4730 struct sigqueue *q; 4731 TaskState *ts = cpu_env->opaque; 4732 4733 if (!ts->signal_pending) 4734 return; 4735 4736 /* FIXME: This is not threadsafe. */ 4737 k = ts->sigtab; 4738 for(sig = 1; sig <= TARGET_NSIG; sig++) { 4739 if (k->pending) 4740 goto handle_signal; 4741 k++; 4742 } 4743 /* if no signal is pending, just return */ 4744 ts->signal_pending = 0; 4745 return; 4746 4747 handle_signal: 4748 #ifdef DEBUG_SIGNAL 4749 fprintf(stderr, "qemu: process signal %d\n", sig); 4750 #endif 4751 /* dequeue signal */ 4752 q = k->first; 4753 k->first = q->next; 4754 if (!k->first) 4755 k->pending = 0; 4756 4757 sig = gdb_handlesig (cpu_env, sig); 4758 if (!sig) { 4759 sa = NULL; 4760 handler = TARGET_SIG_IGN; 4761 } else { 4762 sa = &sigact_table[sig - 1]; 4763 handler = sa->_sa_handler; 4764 } 4765 4766 if (handler == TARGET_SIG_DFL) { 4767 /* default handler : ignore some signal. The other are job control or fatal */ 4768 if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) { 4769 kill(getpid(),SIGSTOP); 4770 } else if (sig != TARGET_SIGCHLD && 4771 sig != TARGET_SIGURG && 4772 sig != TARGET_SIGWINCH && 4773 sig != TARGET_SIGCONT) { 4774 force_sig(sig); 4775 } 4776 } else if (handler == TARGET_SIG_IGN) { 4777 /* ignore sig */ 4778 } else if (handler == TARGET_SIG_ERR) { 4779 force_sig(sig); 4780 } else { 4781 /* compute the blocked signals during the handler execution */ 4782 target_to_host_sigset(&set, &sa->sa_mask); 4783 /* SA_NODEFER indicates that the current signal should not be 4784 blocked during the handler */ 4785 if (!(sa->sa_flags & TARGET_SA_NODEFER)) 4786 sigaddset(&set, target_to_host_signal(sig)); 4787 4788 /* block signals in the handler using Linux */ 4789 sigprocmask(SIG_BLOCK, &set, &old_set); 4790 /* save the previous blocked signal state to restore it at the 4791 end of the signal execution (see do_sigreturn) */ 4792 host_to_target_sigset_internal(&target_old_set, &old_set); 4793 4794 /* if the CPU is in VM86 mode, we restore the 32 bit values */ 4795 #if defined(TARGET_I386) && !defined(TARGET_X86_64) 4796 { 4797 CPUX86State *env = cpu_env; 4798 if (env->eflags & VM_MASK) 4799 save_v86_state(env); 4800 } 4801 #endif 4802 /* prepare the stack frame of the virtual CPU */ 4803 if (sa->sa_flags & TARGET_SA_SIGINFO) 4804 setup_rt_frame(sig, sa, &q->info, &target_old_set, cpu_env); 4805 else 4806 setup_frame(sig, sa, &target_old_set, cpu_env); 4807 if (sa->sa_flags & TARGET_SA_RESETHAND) 4808 sa->_sa_handler = TARGET_SIG_DFL; 4809 } 4810 if (q != &k->info) 4811 free_sigqueue(cpu_env, q); 4812 } 4813