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 "qemu/osdep.h" 20 #include "qemu/bitops.h" 21 #include <sys/ucontext.h> 22 #include <sys/resource.h> 23 24 #include "qemu.h" 25 #include "qemu-common.h" 26 #include "target_signal.h" 27 #include "trace.h" 28 29 static struct target_sigaltstack target_sigaltstack_used = { 30 .ss_sp = 0, 31 .ss_size = 0, 32 .ss_flags = TARGET_SS_DISABLE, 33 }; 34 35 static struct target_sigaction sigact_table[TARGET_NSIG]; 36 37 static void host_signal_handler(int host_signum, siginfo_t *info, 38 void *puc); 39 40 static uint8_t host_to_target_signal_table[_NSIG] = { 41 [SIGHUP] = TARGET_SIGHUP, 42 [SIGINT] = TARGET_SIGINT, 43 [SIGQUIT] = TARGET_SIGQUIT, 44 [SIGILL] = TARGET_SIGILL, 45 [SIGTRAP] = TARGET_SIGTRAP, 46 [SIGABRT] = TARGET_SIGABRT, 47 /* [SIGIOT] = TARGET_SIGIOT,*/ 48 [SIGBUS] = TARGET_SIGBUS, 49 [SIGFPE] = TARGET_SIGFPE, 50 [SIGKILL] = TARGET_SIGKILL, 51 [SIGUSR1] = TARGET_SIGUSR1, 52 [SIGSEGV] = TARGET_SIGSEGV, 53 [SIGUSR2] = TARGET_SIGUSR2, 54 [SIGPIPE] = TARGET_SIGPIPE, 55 [SIGALRM] = TARGET_SIGALRM, 56 [SIGTERM] = TARGET_SIGTERM, 57 #ifdef SIGSTKFLT 58 [SIGSTKFLT] = TARGET_SIGSTKFLT, 59 #endif 60 [SIGCHLD] = TARGET_SIGCHLD, 61 [SIGCONT] = TARGET_SIGCONT, 62 [SIGSTOP] = TARGET_SIGSTOP, 63 [SIGTSTP] = TARGET_SIGTSTP, 64 [SIGTTIN] = TARGET_SIGTTIN, 65 [SIGTTOU] = TARGET_SIGTTOU, 66 [SIGURG] = TARGET_SIGURG, 67 [SIGXCPU] = TARGET_SIGXCPU, 68 [SIGXFSZ] = TARGET_SIGXFSZ, 69 [SIGVTALRM] = TARGET_SIGVTALRM, 70 [SIGPROF] = TARGET_SIGPROF, 71 [SIGWINCH] = TARGET_SIGWINCH, 72 [SIGIO] = TARGET_SIGIO, 73 [SIGPWR] = TARGET_SIGPWR, 74 [SIGSYS] = TARGET_SIGSYS, 75 /* next signals stay the same */ 76 /* Nasty hack: Reverse SIGRTMIN and SIGRTMAX to avoid overlap with 77 host libpthread signals. This assumes no one actually uses SIGRTMAX :-/ 78 To fix this properly we need to do manual signal delivery multiplexed 79 over a single host signal. */ 80 [__SIGRTMIN] = __SIGRTMAX, 81 [__SIGRTMAX] = __SIGRTMIN, 82 }; 83 static uint8_t target_to_host_signal_table[_NSIG]; 84 85 static inline int on_sig_stack(unsigned long sp) 86 { 87 return (sp - target_sigaltstack_used.ss_sp 88 < target_sigaltstack_used.ss_size); 89 } 90 91 static inline int sas_ss_flags(unsigned long sp) 92 { 93 return (target_sigaltstack_used.ss_size == 0 ? SS_DISABLE 94 : on_sig_stack(sp) ? SS_ONSTACK : 0); 95 } 96 97 int host_to_target_signal(int sig) 98 { 99 if (sig < 0 || sig >= _NSIG) 100 return sig; 101 return host_to_target_signal_table[sig]; 102 } 103 104 int target_to_host_signal(int sig) 105 { 106 if (sig < 0 || sig >= _NSIG) 107 return sig; 108 return target_to_host_signal_table[sig]; 109 } 110 111 static inline void target_sigemptyset(target_sigset_t *set) 112 { 113 memset(set, 0, sizeof(*set)); 114 } 115 116 static inline void target_sigaddset(target_sigset_t *set, int signum) 117 { 118 signum--; 119 abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW); 120 set->sig[signum / TARGET_NSIG_BPW] |= mask; 121 } 122 123 static inline int target_sigismember(const target_sigset_t *set, int signum) 124 { 125 signum--; 126 abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW); 127 return ((set->sig[signum / TARGET_NSIG_BPW] & mask) != 0); 128 } 129 130 static void host_to_target_sigset_internal(target_sigset_t *d, 131 const sigset_t *s) 132 { 133 int i; 134 target_sigemptyset(d); 135 for (i = 1; i <= TARGET_NSIG; i++) { 136 if (sigismember(s, i)) { 137 target_sigaddset(d, host_to_target_signal(i)); 138 } 139 } 140 } 141 142 void host_to_target_sigset(target_sigset_t *d, const sigset_t *s) 143 { 144 target_sigset_t d1; 145 int i; 146 147 host_to_target_sigset_internal(&d1, s); 148 for(i = 0;i < TARGET_NSIG_WORDS; i++) 149 d->sig[i] = tswapal(d1.sig[i]); 150 } 151 152 static void target_to_host_sigset_internal(sigset_t *d, 153 const target_sigset_t *s) 154 { 155 int i; 156 sigemptyset(d); 157 for (i = 1; i <= TARGET_NSIG; i++) { 158 if (target_sigismember(s, i)) { 159 sigaddset(d, target_to_host_signal(i)); 160 } 161 } 162 } 163 164 void target_to_host_sigset(sigset_t *d, const target_sigset_t *s) 165 { 166 target_sigset_t s1; 167 int i; 168 169 for(i = 0;i < TARGET_NSIG_WORDS; i++) 170 s1.sig[i] = tswapal(s->sig[i]); 171 target_to_host_sigset_internal(d, &s1); 172 } 173 174 void host_to_target_old_sigset(abi_ulong *old_sigset, 175 const sigset_t *sigset) 176 { 177 target_sigset_t d; 178 host_to_target_sigset(&d, sigset); 179 *old_sigset = d.sig[0]; 180 } 181 182 void target_to_host_old_sigset(sigset_t *sigset, 183 const abi_ulong *old_sigset) 184 { 185 target_sigset_t d; 186 int i; 187 188 d.sig[0] = *old_sigset; 189 for(i = 1;i < TARGET_NSIG_WORDS; i++) 190 d.sig[i] = 0; 191 target_to_host_sigset(sigset, &d); 192 } 193 194 int block_signals(void) 195 { 196 TaskState *ts = (TaskState *)thread_cpu->opaque; 197 sigset_t set; 198 int pending; 199 200 /* It's OK to block everything including SIGSEGV, because we won't 201 * run any further guest code before unblocking signals in 202 * process_pending_signals(). 203 */ 204 sigfillset(&set); 205 sigprocmask(SIG_SETMASK, &set, 0); 206 207 pending = atomic_xchg(&ts->signal_pending, 1); 208 209 return pending; 210 } 211 212 /* Wrapper for sigprocmask function 213 * Emulates a sigprocmask in a safe way for the guest. Note that set and oldset 214 * are host signal set, not guest ones. Returns -TARGET_ERESTARTSYS if 215 * a signal was already pending and the syscall must be restarted, or 216 * 0 on success. 217 * If set is NULL, this is guaranteed not to fail. 218 */ 219 int do_sigprocmask(int how, const sigset_t *set, sigset_t *oldset) 220 { 221 TaskState *ts = (TaskState *)thread_cpu->opaque; 222 223 if (oldset) { 224 *oldset = ts->signal_mask; 225 } 226 227 if (set) { 228 int i; 229 230 if (block_signals()) { 231 return -TARGET_ERESTARTSYS; 232 } 233 234 switch (how) { 235 case SIG_BLOCK: 236 sigorset(&ts->signal_mask, &ts->signal_mask, set); 237 break; 238 case SIG_UNBLOCK: 239 for (i = 1; i <= NSIG; ++i) { 240 if (sigismember(set, i)) { 241 sigdelset(&ts->signal_mask, i); 242 } 243 } 244 break; 245 case SIG_SETMASK: 246 ts->signal_mask = *set; 247 break; 248 default: 249 g_assert_not_reached(); 250 } 251 252 /* Silently ignore attempts to change blocking status of KILL or STOP */ 253 sigdelset(&ts->signal_mask, SIGKILL); 254 sigdelset(&ts->signal_mask, SIGSTOP); 255 } 256 return 0; 257 } 258 259 #if !defined(TARGET_OPENRISC) && !defined(TARGET_UNICORE32) && \ 260 !defined(TARGET_X86_64) 261 /* Just set the guest's signal mask to the specified value; the 262 * caller is assumed to have called block_signals() already. 263 */ 264 static void set_sigmask(const sigset_t *set) 265 { 266 TaskState *ts = (TaskState *)thread_cpu->opaque; 267 268 ts->signal_mask = *set; 269 } 270 #endif 271 272 /* siginfo conversion */ 273 274 static inline void host_to_target_siginfo_noswap(target_siginfo_t *tinfo, 275 const siginfo_t *info) 276 { 277 int sig = host_to_target_signal(info->si_signo); 278 int si_code = info->si_code; 279 int si_type; 280 tinfo->si_signo = sig; 281 tinfo->si_errno = 0; 282 tinfo->si_code = info->si_code; 283 284 /* This is awkward, because we have to use a combination of 285 * the si_code and si_signo to figure out which of the union's 286 * members are valid. (Within the host kernel it is always possible 287 * to tell, but the kernel carefully avoids giving userspace the 288 * high 16 bits of si_code, so we don't have the information to 289 * do this the easy way...) We therefore make our best guess, 290 * bearing in mind that a guest can spoof most of the si_codes 291 * via rt_sigqueueinfo() if it likes. 292 * 293 * Once we have made our guess, we record it in the top 16 bits of 294 * the si_code, so that tswap_siginfo() later can use it. 295 * tswap_siginfo() will strip these top bits out before writing 296 * si_code to the guest (sign-extending the lower bits). 297 */ 298 299 switch (si_code) { 300 case SI_USER: 301 case SI_TKILL: 302 case SI_KERNEL: 303 /* Sent via kill(), tkill() or tgkill(), or direct from the kernel. 304 * These are the only unspoofable si_code values. 305 */ 306 tinfo->_sifields._kill._pid = info->si_pid; 307 tinfo->_sifields._kill._uid = info->si_uid; 308 si_type = QEMU_SI_KILL; 309 break; 310 default: 311 /* Everything else is spoofable. Make best guess based on signal */ 312 switch (sig) { 313 case TARGET_SIGCHLD: 314 tinfo->_sifields._sigchld._pid = info->si_pid; 315 tinfo->_sifields._sigchld._uid = info->si_uid; 316 tinfo->_sifields._sigchld._status 317 = host_to_target_waitstatus(info->si_status); 318 tinfo->_sifields._sigchld._utime = info->si_utime; 319 tinfo->_sifields._sigchld._stime = info->si_stime; 320 si_type = QEMU_SI_CHLD; 321 break; 322 case TARGET_SIGIO: 323 tinfo->_sifields._sigpoll._band = info->si_band; 324 tinfo->_sifields._sigpoll._fd = info->si_fd; 325 si_type = QEMU_SI_POLL; 326 break; 327 default: 328 /* Assume a sigqueue()/mq_notify()/rt_sigqueueinfo() source. */ 329 tinfo->_sifields._rt._pid = info->si_pid; 330 tinfo->_sifields._rt._uid = info->si_uid; 331 /* XXX: potential problem if 64 bit */ 332 tinfo->_sifields._rt._sigval.sival_ptr 333 = (abi_ulong)(unsigned long)info->si_value.sival_ptr; 334 si_type = QEMU_SI_RT; 335 break; 336 } 337 break; 338 } 339 340 tinfo->si_code = deposit32(si_code, 16, 16, si_type); 341 } 342 343 static void tswap_siginfo(target_siginfo_t *tinfo, 344 const target_siginfo_t *info) 345 { 346 int si_type = extract32(info->si_code, 16, 16); 347 int si_code = sextract32(info->si_code, 0, 16); 348 349 __put_user(info->si_signo, &tinfo->si_signo); 350 __put_user(info->si_errno, &tinfo->si_errno); 351 __put_user(si_code, &tinfo->si_code); 352 353 /* We can use our internal marker of which fields in the structure 354 * are valid, rather than duplicating the guesswork of 355 * host_to_target_siginfo_noswap() here. 356 */ 357 switch (si_type) { 358 case QEMU_SI_KILL: 359 __put_user(info->_sifields._kill._pid, &tinfo->_sifields._kill._pid); 360 __put_user(info->_sifields._kill._uid, &tinfo->_sifields._kill._uid); 361 break; 362 case QEMU_SI_TIMER: 363 __put_user(info->_sifields._timer._timer1, 364 &tinfo->_sifields._timer._timer1); 365 __put_user(info->_sifields._timer._timer2, 366 &tinfo->_sifields._timer._timer2); 367 break; 368 case QEMU_SI_POLL: 369 __put_user(info->_sifields._sigpoll._band, 370 &tinfo->_sifields._sigpoll._band); 371 __put_user(info->_sifields._sigpoll._fd, 372 &tinfo->_sifields._sigpoll._fd); 373 break; 374 case QEMU_SI_FAULT: 375 __put_user(info->_sifields._sigfault._addr, 376 &tinfo->_sifields._sigfault._addr); 377 break; 378 case QEMU_SI_CHLD: 379 __put_user(info->_sifields._sigchld._pid, 380 &tinfo->_sifields._sigchld._pid); 381 __put_user(info->_sifields._sigchld._uid, 382 &tinfo->_sifields._sigchld._uid); 383 __put_user(info->_sifields._sigchld._status, 384 &tinfo->_sifields._sigchld._status); 385 __put_user(info->_sifields._sigchld._utime, 386 &tinfo->_sifields._sigchld._utime); 387 __put_user(info->_sifields._sigchld._stime, 388 &tinfo->_sifields._sigchld._stime); 389 break; 390 case QEMU_SI_RT: 391 __put_user(info->_sifields._rt._pid, &tinfo->_sifields._rt._pid); 392 __put_user(info->_sifields._rt._uid, &tinfo->_sifields._rt._uid); 393 __put_user(info->_sifields._rt._sigval.sival_ptr, 394 &tinfo->_sifields._rt._sigval.sival_ptr); 395 break; 396 default: 397 g_assert_not_reached(); 398 } 399 } 400 401 void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info) 402 { 403 host_to_target_siginfo_noswap(tinfo, info); 404 tswap_siginfo(tinfo, tinfo); 405 } 406 407 /* XXX: we support only POSIX RT signals are used. */ 408 /* XXX: find a solution for 64 bit (additional malloced data is needed) */ 409 void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo) 410 { 411 /* This conversion is used only for the rt_sigqueueinfo syscall, 412 * and so we know that the _rt fields are the valid ones. 413 */ 414 abi_ulong sival_ptr; 415 416 __get_user(info->si_signo, &tinfo->si_signo); 417 __get_user(info->si_errno, &tinfo->si_errno); 418 __get_user(info->si_code, &tinfo->si_code); 419 __get_user(info->si_pid, &tinfo->_sifields._rt._pid); 420 __get_user(info->si_uid, &tinfo->_sifields._rt._uid); 421 __get_user(sival_ptr, &tinfo->_sifields._rt._sigval.sival_ptr); 422 info->si_value.sival_ptr = (void *)(long)sival_ptr; 423 } 424 425 static int fatal_signal (int sig) 426 { 427 switch (sig) { 428 case TARGET_SIGCHLD: 429 case TARGET_SIGURG: 430 case TARGET_SIGWINCH: 431 /* Ignored by default. */ 432 return 0; 433 case TARGET_SIGCONT: 434 case TARGET_SIGSTOP: 435 case TARGET_SIGTSTP: 436 case TARGET_SIGTTIN: 437 case TARGET_SIGTTOU: 438 /* Job control signals. */ 439 return 0; 440 default: 441 return 1; 442 } 443 } 444 445 /* returns 1 if given signal should dump core if not handled */ 446 static int core_dump_signal(int sig) 447 { 448 switch (sig) { 449 case TARGET_SIGABRT: 450 case TARGET_SIGFPE: 451 case TARGET_SIGILL: 452 case TARGET_SIGQUIT: 453 case TARGET_SIGSEGV: 454 case TARGET_SIGTRAP: 455 case TARGET_SIGBUS: 456 return (1); 457 default: 458 return (0); 459 } 460 } 461 462 void signal_init(void) 463 { 464 TaskState *ts = (TaskState *)thread_cpu->opaque; 465 struct sigaction act; 466 struct sigaction oact; 467 int i, j; 468 int host_sig; 469 470 /* generate signal conversion tables */ 471 for(i = 1; i < _NSIG; i++) { 472 if (host_to_target_signal_table[i] == 0) 473 host_to_target_signal_table[i] = i; 474 } 475 for(i = 1; i < _NSIG; i++) { 476 j = host_to_target_signal_table[i]; 477 target_to_host_signal_table[j] = i; 478 } 479 480 /* Set the signal mask from the host mask. */ 481 sigprocmask(0, 0, &ts->signal_mask); 482 483 /* set all host signal handlers. ALL signals are blocked during 484 the handlers to serialize them. */ 485 memset(sigact_table, 0, sizeof(sigact_table)); 486 487 sigfillset(&act.sa_mask); 488 act.sa_flags = SA_SIGINFO; 489 act.sa_sigaction = host_signal_handler; 490 for(i = 1; i <= TARGET_NSIG; i++) { 491 host_sig = target_to_host_signal(i); 492 sigaction(host_sig, NULL, &oact); 493 if (oact.sa_sigaction == (void *)SIG_IGN) { 494 sigact_table[i - 1]._sa_handler = TARGET_SIG_IGN; 495 } else if (oact.sa_sigaction == (void *)SIG_DFL) { 496 sigact_table[i - 1]._sa_handler = TARGET_SIG_DFL; 497 } 498 /* If there's already a handler installed then something has 499 gone horribly wrong, so don't even try to handle that case. */ 500 /* Install some handlers for our own use. We need at least 501 SIGSEGV and SIGBUS, to detect exceptions. We can not just 502 trap all signals because it affects syscall interrupt 503 behavior. But do trap all default-fatal signals. */ 504 if (fatal_signal (i)) 505 sigaction(host_sig, &act, NULL); 506 } 507 } 508 509 510 /* abort execution with signal */ 511 static void QEMU_NORETURN force_sig(int target_sig) 512 { 513 CPUState *cpu = thread_cpu; 514 CPUArchState *env = cpu->env_ptr; 515 TaskState *ts = (TaskState *)cpu->opaque; 516 int host_sig, core_dumped = 0; 517 struct sigaction act; 518 519 host_sig = target_to_host_signal(target_sig); 520 trace_user_force_sig(env, target_sig, host_sig); 521 gdb_signalled(env, target_sig); 522 523 /* dump core if supported by target binary format */ 524 if (core_dump_signal(target_sig) && (ts->bprm->core_dump != NULL)) { 525 stop_all_tasks(); 526 core_dumped = 527 ((*ts->bprm->core_dump)(target_sig, env) == 0); 528 } 529 if (core_dumped) { 530 /* we already dumped the core of target process, we don't want 531 * a coredump of qemu itself */ 532 struct rlimit nodump; 533 getrlimit(RLIMIT_CORE, &nodump); 534 nodump.rlim_cur=0; 535 setrlimit(RLIMIT_CORE, &nodump); 536 (void) fprintf(stderr, "qemu: uncaught target signal %d (%s) - %s\n", 537 target_sig, strsignal(host_sig), "core dumped" ); 538 } 539 540 /* The proper exit code for dying from an uncaught signal is 541 * -<signal>. The kernel doesn't allow exit() or _exit() to pass 542 * a negative value. To get the proper exit code we need to 543 * actually die from an uncaught signal. Here the default signal 544 * handler is installed, we send ourself a signal and we wait for 545 * it to arrive. */ 546 sigfillset(&act.sa_mask); 547 act.sa_handler = SIG_DFL; 548 act.sa_flags = 0; 549 sigaction(host_sig, &act, NULL); 550 551 /* For some reason raise(host_sig) doesn't send the signal when 552 * statically linked on x86-64. */ 553 kill(getpid(), host_sig); 554 555 /* Make sure the signal isn't masked (just reuse the mask inside 556 of act) */ 557 sigdelset(&act.sa_mask, host_sig); 558 sigsuspend(&act.sa_mask); 559 560 /* unreachable */ 561 abort(); 562 } 563 564 /* queue a signal so that it will be send to the virtual CPU as soon 565 as possible */ 566 int queue_signal(CPUArchState *env, int sig, target_siginfo_t *info) 567 { 568 CPUState *cpu = ENV_GET_CPU(env); 569 TaskState *ts = cpu->opaque; 570 571 trace_user_queue_signal(env, sig); 572 573 /* Currently all callers define siginfo structures which 574 * use the _sifields._sigfault union member, so we can 575 * set the type here. If that changes we should push this 576 * out so the si_type is passed in by callers. 577 */ 578 info->si_code = deposit32(info->si_code, 16, 16, QEMU_SI_FAULT); 579 580 ts->sync_signal.info = *info; 581 ts->sync_signal.pending = sig; 582 /* signal that a new signal is pending */ 583 atomic_set(&ts->signal_pending, 1); 584 return 1; /* indicates that the signal was queued */ 585 } 586 587 #ifndef HAVE_SAFE_SYSCALL 588 static inline void rewind_if_in_safe_syscall(void *puc) 589 { 590 /* Default version: never rewind */ 591 } 592 #endif 593 594 static void host_signal_handler(int host_signum, siginfo_t *info, 595 void *puc) 596 { 597 CPUArchState *env = thread_cpu->env_ptr; 598 CPUState *cpu = ENV_GET_CPU(env); 599 TaskState *ts = cpu->opaque; 600 601 int sig; 602 target_siginfo_t tinfo; 603 ucontext_t *uc = puc; 604 struct emulated_sigtable *k; 605 606 /* the CPU emulator uses some host signals to detect exceptions, 607 we forward to it some signals */ 608 if ((host_signum == SIGSEGV || host_signum == SIGBUS) 609 && info->si_code > 0) { 610 if (cpu_signal_handler(host_signum, info, puc)) 611 return; 612 } 613 614 /* get target signal number */ 615 sig = host_to_target_signal(host_signum); 616 if (sig < 1 || sig > TARGET_NSIG) 617 return; 618 trace_user_host_signal(env, host_signum, sig); 619 620 rewind_if_in_safe_syscall(puc); 621 622 host_to_target_siginfo_noswap(&tinfo, info); 623 k = &ts->sigtab[sig - 1]; 624 k->info = tinfo; 625 k->pending = sig; 626 ts->signal_pending = 1; 627 628 /* Block host signals until target signal handler entered. We 629 * can't block SIGSEGV or SIGBUS while we're executing guest 630 * code in case the guest code provokes one in the window between 631 * now and it getting out to the main loop. Signals will be 632 * unblocked again in process_pending_signals(). 633 */ 634 sigfillset(&uc->uc_sigmask); 635 sigdelset(&uc->uc_sigmask, SIGSEGV); 636 sigdelset(&uc->uc_sigmask, SIGBUS); 637 638 /* interrupt the virtual CPU as soon as possible */ 639 cpu_exit(thread_cpu); 640 } 641 642 /* do_sigaltstack() returns target values and errnos. */ 643 /* compare linux/kernel/signal.c:do_sigaltstack() */ 644 abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp) 645 { 646 int ret; 647 struct target_sigaltstack oss; 648 649 /* XXX: test errors */ 650 if(uoss_addr) 651 { 652 __put_user(target_sigaltstack_used.ss_sp, &oss.ss_sp); 653 __put_user(target_sigaltstack_used.ss_size, &oss.ss_size); 654 __put_user(sas_ss_flags(sp), &oss.ss_flags); 655 } 656 657 if(uss_addr) 658 { 659 struct target_sigaltstack *uss; 660 struct target_sigaltstack ss; 661 size_t minstacksize = TARGET_MINSIGSTKSZ; 662 663 #if defined(TARGET_PPC64) 664 /* ELF V2 for PPC64 has a 4K minimum stack size for signal handlers */ 665 struct image_info *image = ((TaskState *)thread_cpu->opaque)->info; 666 if (get_ppc64_abi(image) > 1) { 667 minstacksize = 4096; 668 } 669 #endif 670 671 ret = -TARGET_EFAULT; 672 if (!lock_user_struct(VERIFY_READ, uss, uss_addr, 1)) { 673 goto out; 674 } 675 __get_user(ss.ss_sp, &uss->ss_sp); 676 __get_user(ss.ss_size, &uss->ss_size); 677 __get_user(ss.ss_flags, &uss->ss_flags); 678 unlock_user_struct(uss, uss_addr, 0); 679 680 ret = -TARGET_EPERM; 681 if (on_sig_stack(sp)) 682 goto out; 683 684 ret = -TARGET_EINVAL; 685 if (ss.ss_flags != TARGET_SS_DISABLE 686 && ss.ss_flags != TARGET_SS_ONSTACK 687 && ss.ss_flags != 0) 688 goto out; 689 690 if (ss.ss_flags == TARGET_SS_DISABLE) { 691 ss.ss_size = 0; 692 ss.ss_sp = 0; 693 } else { 694 ret = -TARGET_ENOMEM; 695 if (ss.ss_size < minstacksize) { 696 goto out; 697 } 698 } 699 700 target_sigaltstack_used.ss_sp = ss.ss_sp; 701 target_sigaltstack_used.ss_size = ss.ss_size; 702 } 703 704 if (uoss_addr) { 705 ret = -TARGET_EFAULT; 706 if (copy_to_user(uoss_addr, &oss, sizeof(oss))) 707 goto out; 708 } 709 710 ret = 0; 711 out: 712 return ret; 713 } 714 715 /* do_sigaction() return target values and host errnos */ 716 int do_sigaction(int sig, const struct target_sigaction *act, 717 struct target_sigaction *oact) 718 { 719 struct target_sigaction *k; 720 struct sigaction act1; 721 int host_sig; 722 int ret = 0; 723 724 if (sig < 1 || sig > TARGET_NSIG || sig == TARGET_SIGKILL || sig == TARGET_SIGSTOP) { 725 return -TARGET_EINVAL; 726 } 727 728 if (block_signals()) { 729 return -TARGET_ERESTARTSYS; 730 } 731 732 k = &sigact_table[sig - 1]; 733 if (oact) { 734 __put_user(k->_sa_handler, &oact->_sa_handler); 735 __put_user(k->sa_flags, &oact->sa_flags); 736 #if !defined(TARGET_MIPS) 737 __put_user(k->sa_restorer, &oact->sa_restorer); 738 #endif 739 /* Not swapped. */ 740 oact->sa_mask = k->sa_mask; 741 } 742 if (act) { 743 /* FIXME: This is not threadsafe. */ 744 __get_user(k->_sa_handler, &act->_sa_handler); 745 __get_user(k->sa_flags, &act->sa_flags); 746 #if !defined(TARGET_MIPS) 747 __get_user(k->sa_restorer, &act->sa_restorer); 748 #endif 749 /* To be swapped in target_to_host_sigset. */ 750 k->sa_mask = act->sa_mask; 751 752 /* we update the host linux signal state */ 753 host_sig = target_to_host_signal(sig); 754 if (host_sig != SIGSEGV && host_sig != SIGBUS) { 755 sigfillset(&act1.sa_mask); 756 act1.sa_flags = SA_SIGINFO; 757 if (k->sa_flags & TARGET_SA_RESTART) 758 act1.sa_flags |= SA_RESTART; 759 /* NOTE: it is important to update the host kernel signal 760 ignore state to avoid getting unexpected interrupted 761 syscalls */ 762 if (k->_sa_handler == TARGET_SIG_IGN) { 763 act1.sa_sigaction = (void *)SIG_IGN; 764 } else if (k->_sa_handler == TARGET_SIG_DFL) { 765 if (fatal_signal (sig)) 766 act1.sa_sigaction = host_signal_handler; 767 else 768 act1.sa_sigaction = (void *)SIG_DFL; 769 } else { 770 act1.sa_sigaction = host_signal_handler; 771 } 772 ret = sigaction(host_sig, &act1, NULL); 773 } 774 } 775 return ret; 776 } 777 778 #if defined(TARGET_I386) && TARGET_ABI_BITS == 32 779 780 /* from the Linux kernel */ 781 782 struct target_fpreg { 783 uint16_t significand[4]; 784 uint16_t exponent; 785 }; 786 787 struct target_fpxreg { 788 uint16_t significand[4]; 789 uint16_t exponent; 790 uint16_t padding[3]; 791 }; 792 793 struct target_xmmreg { 794 abi_ulong element[4]; 795 }; 796 797 struct target_fpstate { 798 /* Regular FPU environment */ 799 abi_ulong cw; 800 abi_ulong sw; 801 abi_ulong tag; 802 abi_ulong ipoff; 803 abi_ulong cssel; 804 abi_ulong dataoff; 805 abi_ulong datasel; 806 struct target_fpreg _st[8]; 807 uint16_t status; 808 uint16_t magic; /* 0xffff = regular FPU data only */ 809 810 /* FXSR FPU environment */ 811 abi_ulong _fxsr_env[6]; /* FXSR FPU env is ignored */ 812 abi_ulong mxcsr; 813 abi_ulong reserved; 814 struct target_fpxreg _fxsr_st[8]; /* FXSR FPU reg data is ignored */ 815 struct target_xmmreg _xmm[8]; 816 abi_ulong padding[56]; 817 }; 818 819 #define X86_FXSR_MAGIC 0x0000 820 821 struct target_sigcontext { 822 uint16_t gs, __gsh; 823 uint16_t fs, __fsh; 824 uint16_t es, __esh; 825 uint16_t ds, __dsh; 826 abi_ulong edi; 827 abi_ulong esi; 828 abi_ulong ebp; 829 abi_ulong esp; 830 abi_ulong ebx; 831 abi_ulong edx; 832 abi_ulong ecx; 833 abi_ulong eax; 834 abi_ulong trapno; 835 abi_ulong err; 836 abi_ulong eip; 837 uint16_t cs, __csh; 838 abi_ulong eflags; 839 abi_ulong esp_at_signal; 840 uint16_t ss, __ssh; 841 abi_ulong fpstate; /* pointer */ 842 abi_ulong oldmask; 843 abi_ulong cr2; 844 }; 845 846 struct target_ucontext { 847 abi_ulong tuc_flags; 848 abi_ulong tuc_link; 849 target_stack_t tuc_stack; 850 struct target_sigcontext tuc_mcontext; 851 target_sigset_t tuc_sigmask; /* mask last for extensibility */ 852 }; 853 854 struct sigframe 855 { 856 abi_ulong pretcode; 857 int sig; 858 struct target_sigcontext sc; 859 struct target_fpstate fpstate; 860 abi_ulong extramask[TARGET_NSIG_WORDS-1]; 861 char retcode[8]; 862 }; 863 864 struct rt_sigframe 865 { 866 abi_ulong pretcode; 867 int sig; 868 abi_ulong pinfo; 869 abi_ulong puc; 870 struct target_siginfo info; 871 struct target_ucontext uc; 872 struct target_fpstate fpstate; 873 char retcode[8]; 874 }; 875 876 /* 877 * Set up a signal frame. 878 */ 879 880 /* XXX: save x87 state */ 881 static void setup_sigcontext(struct target_sigcontext *sc, 882 struct target_fpstate *fpstate, CPUX86State *env, abi_ulong mask, 883 abi_ulong fpstate_addr) 884 { 885 CPUState *cs = CPU(x86_env_get_cpu(env)); 886 uint16_t magic; 887 888 /* already locked in setup_frame() */ 889 __put_user(env->segs[R_GS].selector, (unsigned int *)&sc->gs); 890 __put_user(env->segs[R_FS].selector, (unsigned int *)&sc->fs); 891 __put_user(env->segs[R_ES].selector, (unsigned int *)&sc->es); 892 __put_user(env->segs[R_DS].selector, (unsigned int *)&sc->ds); 893 __put_user(env->regs[R_EDI], &sc->edi); 894 __put_user(env->regs[R_ESI], &sc->esi); 895 __put_user(env->regs[R_EBP], &sc->ebp); 896 __put_user(env->regs[R_ESP], &sc->esp); 897 __put_user(env->regs[R_EBX], &sc->ebx); 898 __put_user(env->regs[R_EDX], &sc->edx); 899 __put_user(env->regs[R_ECX], &sc->ecx); 900 __put_user(env->regs[R_EAX], &sc->eax); 901 __put_user(cs->exception_index, &sc->trapno); 902 __put_user(env->error_code, &sc->err); 903 __put_user(env->eip, &sc->eip); 904 __put_user(env->segs[R_CS].selector, (unsigned int *)&sc->cs); 905 __put_user(env->eflags, &sc->eflags); 906 __put_user(env->regs[R_ESP], &sc->esp_at_signal); 907 __put_user(env->segs[R_SS].selector, (unsigned int *)&sc->ss); 908 909 cpu_x86_fsave(env, fpstate_addr, 1); 910 fpstate->status = fpstate->sw; 911 magic = 0xffff; 912 __put_user(magic, &fpstate->magic); 913 __put_user(fpstate_addr, &sc->fpstate); 914 915 /* non-iBCS2 extensions.. */ 916 __put_user(mask, &sc->oldmask); 917 __put_user(env->cr[2], &sc->cr2); 918 } 919 920 /* 921 * Determine which stack to use.. 922 */ 923 924 static inline abi_ulong 925 get_sigframe(struct target_sigaction *ka, CPUX86State *env, size_t frame_size) 926 { 927 unsigned long esp; 928 929 /* Default to using normal stack */ 930 esp = env->regs[R_ESP]; 931 /* This is the X/Open sanctioned signal stack switching. */ 932 if (ka->sa_flags & TARGET_SA_ONSTACK) { 933 if (sas_ss_flags(esp) == 0) { 934 esp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 935 } 936 } else { 937 938 /* This is the legacy signal stack switching. */ 939 if ((env->segs[R_SS].selector & 0xffff) != __USER_DS && 940 !(ka->sa_flags & TARGET_SA_RESTORER) && 941 ka->sa_restorer) { 942 esp = (unsigned long) ka->sa_restorer; 943 } 944 } 945 return (esp - frame_size) & -8ul; 946 } 947 948 /* compare linux/arch/i386/kernel/signal.c:setup_frame() */ 949 static void setup_frame(int sig, struct target_sigaction *ka, 950 target_sigset_t *set, CPUX86State *env) 951 { 952 abi_ulong frame_addr; 953 struct sigframe *frame; 954 int i; 955 956 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 957 trace_user_setup_frame(env, frame_addr); 958 959 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 960 goto give_sigsegv; 961 962 __put_user(sig, &frame->sig); 963 964 setup_sigcontext(&frame->sc, &frame->fpstate, env, set->sig[0], 965 frame_addr + offsetof(struct sigframe, fpstate)); 966 967 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 968 __put_user(set->sig[i], &frame->extramask[i - 1]); 969 } 970 971 /* Set up to return from userspace. If provided, use a stub 972 already in userspace. */ 973 if (ka->sa_flags & TARGET_SA_RESTORER) { 974 __put_user(ka->sa_restorer, &frame->pretcode); 975 } else { 976 uint16_t val16; 977 abi_ulong retcode_addr; 978 retcode_addr = frame_addr + offsetof(struct sigframe, retcode); 979 __put_user(retcode_addr, &frame->pretcode); 980 /* This is popl %eax ; movl $,%eax ; int $0x80 */ 981 val16 = 0xb858; 982 __put_user(val16, (uint16_t *)(frame->retcode+0)); 983 __put_user(TARGET_NR_sigreturn, (int *)(frame->retcode+2)); 984 val16 = 0x80cd; 985 __put_user(val16, (uint16_t *)(frame->retcode+6)); 986 } 987 988 989 /* Set up registers for signal handler */ 990 env->regs[R_ESP] = frame_addr; 991 env->eip = ka->_sa_handler; 992 993 cpu_x86_load_seg(env, R_DS, __USER_DS); 994 cpu_x86_load_seg(env, R_ES, __USER_DS); 995 cpu_x86_load_seg(env, R_SS, __USER_DS); 996 cpu_x86_load_seg(env, R_CS, __USER_CS); 997 env->eflags &= ~TF_MASK; 998 999 unlock_user_struct(frame, frame_addr, 1); 1000 1001 return; 1002 1003 give_sigsegv: 1004 if (sig == TARGET_SIGSEGV) { 1005 ka->_sa_handler = TARGET_SIG_DFL; 1006 } 1007 force_sig(TARGET_SIGSEGV /* , current */); 1008 } 1009 1010 /* compare linux/arch/i386/kernel/signal.c:setup_rt_frame() */ 1011 static void setup_rt_frame(int sig, struct target_sigaction *ka, 1012 target_siginfo_t *info, 1013 target_sigset_t *set, CPUX86State *env) 1014 { 1015 abi_ulong frame_addr, addr; 1016 struct rt_sigframe *frame; 1017 int i; 1018 1019 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 1020 trace_user_setup_rt_frame(env, frame_addr); 1021 1022 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 1023 goto give_sigsegv; 1024 1025 __put_user(sig, &frame->sig); 1026 addr = frame_addr + offsetof(struct rt_sigframe, info); 1027 __put_user(addr, &frame->pinfo); 1028 addr = frame_addr + offsetof(struct rt_sigframe, uc); 1029 __put_user(addr, &frame->puc); 1030 tswap_siginfo(&frame->info, info); 1031 1032 /* Create the ucontext. */ 1033 __put_user(0, &frame->uc.tuc_flags); 1034 __put_user(0, &frame->uc.tuc_link); 1035 __put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp); 1036 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), 1037 &frame->uc.tuc_stack.ss_flags); 1038 __put_user(target_sigaltstack_used.ss_size, 1039 &frame->uc.tuc_stack.ss_size); 1040 setup_sigcontext(&frame->uc.tuc_mcontext, &frame->fpstate, env, 1041 set->sig[0], frame_addr + offsetof(struct rt_sigframe, fpstate)); 1042 1043 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 1044 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]); 1045 } 1046 1047 /* Set up to return from userspace. If provided, use a stub 1048 already in userspace. */ 1049 if (ka->sa_flags & TARGET_SA_RESTORER) { 1050 __put_user(ka->sa_restorer, &frame->pretcode); 1051 } else { 1052 uint16_t val16; 1053 addr = frame_addr + offsetof(struct rt_sigframe, retcode); 1054 __put_user(addr, &frame->pretcode); 1055 /* This is movl $,%eax ; int $0x80 */ 1056 __put_user(0xb8, (char *)(frame->retcode+0)); 1057 __put_user(TARGET_NR_rt_sigreturn, (int *)(frame->retcode+1)); 1058 val16 = 0x80cd; 1059 __put_user(val16, (uint16_t *)(frame->retcode+5)); 1060 } 1061 1062 /* Set up registers for signal handler */ 1063 env->regs[R_ESP] = frame_addr; 1064 env->eip = ka->_sa_handler; 1065 1066 cpu_x86_load_seg(env, R_DS, __USER_DS); 1067 cpu_x86_load_seg(env, R_ES, __USER_DS); 1068 cpu_x86_load_seg(env, R_SS, __USER_DS); 1069 cpu_x86_load_seg(env, R_CS, __USER_CS); 1070 env->eflags &= ~TF_MASK; 1071 1072 unlock_user_struct(frame, frame_addr, 1); 1073 1074 return; 1075 1076 give_sigsegv: 1077 if (sig == TARGET_SIGSEGV) { 1078 ka->_sa_handler = TARGET_SIG_DFL; 1079 } 1080 force_sig(TARGET_SIGSEGV /* , current */); 1081 } 1082 1083 static int 1084 restore_sigcontext(CPUX86State *env, struct target_sigcontext *sc) 1085 { 1086 unsigned int err = 0; 1087 abi_ulong fpstate_addr; 1088 unsigned int tmpflags; 1089 1090 cpu_x86_load_seg(env, R_GS, tswap16(sc->gs)); 1091 cpu_x86_load_seg(env, R_FS, tswap16(sc->fs)); 1092 cpu_x86_load_seg(env, R_ES, tswap16(sc->es)); 1093 cpu_x86_load_seg(env, R_DS, tswap16(sc->ds)); 1094 1095 env->regs[R_EDI] = tswapl(sc->edi); 1096 env->regs[R_ESI] = tswapl(sc->esi); 1097 env->regs[R_EBP] = tswapl(sc->ebp); 1098 env->regs[R_ESP] = tswapl(sc->esp); 1099 env->regs[R_EBX] = tswapl(sc->ebx); 1100 env->regs[R_EDX] = tswapl(sc->edx); 1101 env->regs[R_ECX] = tswapl(sc->ecx); 1102 env->regs[R_EAX] = tswapl(sc->eax); 1103 env->eip = tswapl(sc->eip); 1104 1105 cpu_x86_load_seg(env, R_CS, lduw_p(&sc->cs) | 3); 1106 cpu_x86_load_seg(env, R_SS, lduw_p(&sc->ss) | 3); 1107 1108 tmpflags = tswapl(sc->eflags); 1109 env->eflags = (env->eflags & ~0x40DD5) | (tmpflags & 0x40DD5); 1110 // regs->orig_eax = -1; /* disable syscall checks */ 1111 1112 fpstate_addr = tswapl(sc->fpstate); 1113 if (fpstate_addr != 0) { 1114 if (!access_ok(VERIFY_READ, fpstate_addr, 1115 sizeof(struct target_fpstate))) 1116 goto badframe; 1117 cpu_x86_frstor(env, fpstate_addr, 1); 1118 } 1119 1120 return err; 1121 badframe: 1122 return 1; 1123 } 1124 1125 long do_sigreturn(CPUX86State *env) 1126 { 1127 struct sigframe *frame; 1128 abi_ulong frame_addr = env->regs[R_ESP] - 8; 1129 target_sigset_t target_set; 1130 sigset_t set; 1131 int i; 1132 1133 trace_user_do_sigreturn(env, frame_addr); 1134 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 1135 goto badframe; 1136 /* set blocked signals */ 1137 __get_user(target_set.sig[0], &frame->sc.oldmask); 1138 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 1139 __get_user(target_set.sig[i], &frame->extramask[i - 1]); 1140 } 1141 1142 target_to_host_sigset_internal(&set, &target_set); 1143 set_sigmask(&set); 1144 1145 /* restore registers */ 1146 if (restore_sigcontext(env, &frame->sc)) 1147 goto badframe; 1148 unlock_user_struct(frame, frame_addr, 0); 1149 return -TARGET_QEMU_ESIGRETURN; 1150 1151 badframe: 1152 unlock_user_struct(frame, frame_addr, 0); 1153 force_sig(TARGET_SIGSEGV); 1154 return 0; 1155 } 1156 1157 long do_rt_sigreturn(CPUX86State *env) 1158 { 1159 abi_ulong frame_addr; 1160 struct rt_sigframe *frame; 1161 sigset_t set; 1162 1163 frame_addr = env->regs[R_ESP] - 4; 1164 trace_user_do_rt_sigreturn(env, frame_addr); 1165 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 1166 goto badframe; 1167 target_to_host_sigset(&set, &frame->uc.tuc_sigmask); 1168 set_sigmask(&set); 1169 1170 if (restore_sigcontext(env, &frame->uc.tuc_mcontext)) { 1171 goto badframe; 1172 } 1173 1174 if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe, uc.tuc_stack), 0, 1175 get_sp_from_cpustate(env)) == -EFAULT) { 1176 goto badframe; 1177 } 1178 1179 unlock_user_struct(frame, frame_addr, 0); 1180 return -TARGET_QEMU_ESIGRETURN; 1181 1182 badframe: 1183 unlock_user_struct(frame, frame_addr, 0); 1184 force_sig(TARGET_SIGSEGV); 1185 return 0; 1186 } 1187 1188 #elif defined(TARGET_AARCH64) 1189 1190 struct target_sigcontext { 1191 uint64_t fault_address; 1192 /* AArch64 registers */ 1193 uint64_t regs[31]; 1194 uint64_t sp; 1195 uint64_t pc; 1196 uint64_t pstate; 1197 /* 4K reserved for FP/SIMD state and future expansion */ 1198 char __reserved[4096] __attribute__((__aligned__(16))); 1199 }; 1200 1201 struct target_ucontext { 1202 abi_ulong tuc_flags; 1203 abi_ulong tuc_link; 1204 target_stack_t tuc_stack; 1205 target_sigset_t tuc_sigmask; 1206 /* glibc uses a 1024-bit sigset_t */ 1207 char __unused[1024 / 8 - sizeof(target_sigset_t)]; 1208 /* last for future expansion */ 1209 struct target_sigcontext tuc_mcontext; 1210 }; 1211 1212 /* 1213 * Header to be used at the beginning of structures extending the user 1214 * context. Such structures must be placed after the rt_sigframe on the stack 1215 * and be 16-byte aligned. The last structure must be a dummy one with the 1216 * magic and size set to 0. 1217 */ 1218 struct target_aarch64_ctx { 1219 uint32_t magic; 1220 uint32_t size; 1221 }; 1222 1223 #define TARGET_FPSIMD_MAGIC 0x46508001 1224 1225 struct target_fpsimd_context { 1226 struct target_aarch64_ctx head; 1227 uint32_t fpsr; 1228 uint32_t fpcr; 1229 uint64_t vregs[32 * 2]; /* really uint128_t vregs[32] */ 1230 }; 1231 1232 /* 1233 * Auxiliary context saved in the sigcontext.__reserved array. Not exported to 1234 * user space as it will change with the addition of new context. User space 1235 * should check the magic/size information. 1236 */ 1237 struct target_aux_context { 1238 struct target_fpsimd_context fpsimd; 1239 /* additional context to be added before "end" */ 1240 struct target_aarch64_ctx end; 1241 }; 1242 1243 struct target_rt_sigframe { 1244 struct target_siginfo info; 1245 struct target_ucontext uc; 1246 uint64_t fp; 1247 uint64_t lr; 1248 uint32_t tramp[2]; 1249 }; 1250 1251 static int target_setup_sigframe(struct target_rt_sigframe *sf, 1252 CPUARMState *env, target_sigset_t *set) 1253 { 1254 int i; 1255 struct target_aux_context *aux = 1256 (struct target_aux_context *)sf->uc.tuc_mcontext.__reserved; 1257 1258 /* set up the stack frame for unwinding */ 1259 __put_user(env->xregs[29], &sf->fp); 1260 __put_user(env->xregs[30], &sf->lr); 1261 1262 for (i = 0; i < 31; i++) { 1263 __put_user(env->xregs[i], &sf->uc.tuc_mcontext.regs[i]); 1264 } 1265 __put_user(env->xregs[31], &sf->uc.tuc_mcontext.sp); 1266 __put_user(env->pc, &sf->uc.tuc_mcontext.pc); 1267 __put_user(pstate_read(env), &sf->uc.tuc_mcontext.pstate); 1268 1269 __put_user(env->exception.vaddress, &sf->uc.tuc_mcontext.fault_address); 1270 1271 for (i = 0; i < TARGET_NSIG_WORDS; i++) { 1272 __put_user(set->sig[i], &sf->uc.tuc_sigmask.sig[i]); 1273 } 1274 1275 for (i = 0; i < 32; i++) { 1276 #ifdef TARGET_WORDS_BIGENDIAN 1277 __put_user(env->vfp.regs[i * 2], &aux->fpsimd.vregs[i * 2 + 1]); 1278 __put_user(env->vfp.regs[i * 2 + 1], &aux->fpsimd.vregs[i * 2]); 1279 #else 1280 __put_user(env->vfp.regs[i * 2], &aux->fpsimd.vregs[i * 2]); 1281 __put_user(env->vfp.regs[i * 2 + 1], &aux->fpsimd.vregs[i * 2 + 1]); 1282 #endif 1283 } 1284 __put_user(vfp_get_fpsr(env), &aux->fpsimd.fpsr); 1285 __put_user(vfp_get_fpcr(env), &aux->fpsimd.fpcr); 1286 __put_user(TARGET_FPSIMD_MAGIC, &aux->fpsimd.head.magic); 1287 __put_user(sizeof(struct target_fpsimd_context), 1288 &aux->fpsimd.head.size); 1289 1290 /* set the "end" magic */ 1291 __put_user(0, &aux->end.magic); 1292 __put_user(0, &aux->end.size); 1293 1294 return 0; 1295 } 1296 1297 static int target_restore_sigframe(CPUARMState *env, 1298 struct target_rt_sigframe *sf) 1299 { 1300 sigset_t set; 1301 int i; 1302 struct target_aux_context *aux = 1303 (struct target_aux_context *)sf->uc.tuc_mcontext.__reserved; 1304 uint32_t magic, size, fpsr, fpcr; 1305 uint64_t pstate; 1306 1307 target_to_host_sigset(&set, &sf->uc.tuc_sigmask); 1308 set_sigmask(&set); 1309 1310 for (i = 0; i < 31; i++) { 1311 __get_user(env->xregs[i], &sf->uc.tuc_mcontext.regs[i]); 1312 } 1313 1314 __get_user(env->xregs[31], &sf->uc.tuc_mcontext.sp); 1315 __get_user(env->pc, &sf->uc.tuc_mcontext.pc); 1316 __get_user(pstate, &sf->uc.tuc_mcontext.pstate); 1317 pstate_write(env, pstate); 1318 1319 __get_user(magic, &aux->fpsimd.head.magic); 1320 __get_user(size, &aux->fpsimd.head.size); 1321 1322 if (magic != TARGET_FPSIMD_MAGIC 1323 || size != sizeof(struct target_fpsimd_context)) { 1324 return 1; 1325 } 1326 1327 for (i = 0; i < 32; i++) { 1328 #ifdef TARGET_WORDS_BIGENDIAN 1329 __get_user(env->vfp.regs[i * 2], &aux->fpsimd.vregs[i * 2 + 1]); 1330 __get_user(env->vfp.regs[i * 2 + 1], &aux->fpsimd.vregs[i * 2]); 1331 #else 1332 __get_user(env->vfp.regs[i * 2], &aux->fpsimd.vregs[i * 2]); 1333 __get_user(env->vfp.regs[i * 2 + 1], &aux->fpsimd.vregs[i * 2 + 1]); 1334 #endif 1335 } 1336 __get_user(fpsr, &aux->fpsimd.fpsr); 1337 vfp_set_fpsr(env, fpsr); 1338 __get_user(fpcr, &aux->fpsimd.fpcr); 1339 vfp_set_fpcr(env, fpcr); 1340 1341 return 0; 1342 } 1343 1344 static abi_ulong get_sigframe(struct target_sigaction *ka, CPUARMState *env) 1345 { 1346 abi_ulong sp; 1347 1348 sp = env->xregs[31]; 1349 1350 /* 1351 * This is the X/Open sanctioned signal stack switching. 1352 */ 1353 if ((ka->sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp)) { 1354 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 1355 } 1356 1357 sp = (sp - sizeof(struct target_rt_sigframe)) & ~15; 1358 1359 return sp; 1360 } 1361 1362 static void target_setup_frame(int usig, struct target_sigaction *ka, 1363 target_siginfo_t *info, target_sigset_t *set, 1364 CPUARMState *env) 1365 { 1366 struct target_rt_sigframe *frame; 1367 abi_ulong frame_addr, return_addr; 1368 1369 frame_addr = get_sigframe(ka, env); 1370 trace_user_setup_frame(env, frame_addr); 1371 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 1372 goto give_sigsegv; 1373 } 1374 1375 __put_user(0, &frame->uc.tuc_flags); 1376 __put_user(0, &frame->uc.tuc_link); 1377 1378 __put_user(target_sigaltstack_used.ss_sp, 1379 &frame->uc.tuc_stack.ss_sp); 1380 __put_user(sas_ss_flags(env->xregs[31]), 1381 &frame->uc.tuc_stack.ss_flags); 1382 __put_user(target_sigaltstack_used.ss_size, 1383 &frame->uc.tuc_stack.ss_size); 1384 target_setup_sigframe(frame, env, set); 1385 if (ka->sa_flags & TARGET_SA_RESTORER) { 1386 return_addr = ka->sa_restorer; 1387 } else { 1388 /* mov x8,#__NR_rt_sigreturn; svc #0 */ 1389 __put_user(0xd2801168, &frame->tramp[0]); 1390 __put_user(0xd4000001, &frame->tramp[1]); 1391 return_addr = frame_addr + offsetof(struct target_rt_sigframe, tramp); 1392 } 1393 env->xregs[0] = usig; 1394 env->xregs[31] = frame_addr; 1395 env->xregs[29] = env->xregs[31] + offsetof(struct target_rt_sigframe, fp); 1396 env->pc = ka->_sa_handler; 1397 env->xregs[30] = return_addr; 1398 if (info) { 1399 tswap_siginfo(&frame->info, info); 1400 env->xregs[1] = frame_addr + offsetof(struct target_rt_sigframe, info); 1401 env->xregs[2] = frame_addr + offsetof(struct target_rt_sigframe, uc); 1402 } 1403 1404 unlock_user_struct(frame, frame_addr, 1); 1405 return; 1406 1407 give_sigsegv: 1408 unlock_user_struct(frame, frame_addr, 1); 1409 force_sig(TARGET_SIGSEGV); 1410 } 1411 1412 static void setup_rt_frame(int sig, struct target_sigaction *ka, 1413 target_siginfo_t *info, target_sigset_t *set, 1414 CPUARMState *env) 1415 { 1416 target_setup_frame(sig, ka, info, set, env); 1417 } 1418 1419 static void setup_frame(int sig, struct target_sigaction *ka, 1420 target_sigset_t *set, CPUARMState *env) 1421 { 1422 target_setup_frame(sig, ka, 0, set, env); 1423 } 1424 1425 long do_rt_sigreturn(CPUARMState *env) 1426 { 1427 struct target_rt_sigframe *frame = NULL; 1428 abi_ulong frame_addr = env->xregs[31]; 1429 1430 trace_user_do_rt_sigreturn(env, frame_addr); 1431 if (frame_addr & 15) { 1432 goto badframe; 1433 } 1434 1435 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) { 1436 goto badframe; 1437 } 1438 1439 if (target_restore_sigframe(env, frame)) { 1440 goto badframe; 1441 } 1442 1443 if (do_sigaltstack(frame_addr + 1444 offsetof(struct target_rt_sigframe, uc.tuc_stack), 1445 0, get_sp_from_cpustate(env)) == -EFAULT) { 1446 goto badframe; 1447 } 1448 1449 unlock_user_struct(frame, frame_addr, 0); 1450 return -TARGET_QEMU_ESIGRETURN; 1451 1452 badframe: 1453 unlock_user_struct(frame, frame_addr, 0); 1454 force_sig(TARGET_SIGSEGV); 1455 return 0; 1456 } 1457 1458 long do_sigreturn(CPUARMState *env) 1459 { 1460 return do_rt_sigreturn(env); 1461 } 1462 1463 #elif defined(TARGET_ARM) 1464 1465 struct target_sigcontext { 1466 abi_ulong trap_no; 1467 abi_ulong error_code; 1468 abi_ulong oldmask; 1469 abi_ulong arm_r0; 1470 abi_ulong arm_r1; 1471 abi_ulong arm_r2; 1472 abi_ulong arm_r3; 1473 abi_ulong arm_r4; 1474 abi_ulong arm_r5; 1475 abi_ulong arm_r6; 1476 abi_ulong arm_r7; 1477 abi_ulong arm_r8; 1478 abi_ulong arm_r9; 1479 abi_ulong arm_r10; 1480 abi_ulong arm_fp; 1481 abi_ulong arm_ip; 1482 abi_ulong arm_sp; 1483 abi_ulong arm_lr; 1484 abi_ulong arm_pc; 1485 abi_ulong arm_cpsr; 1486 abi_ulong fault_address; 1487 }; 1488 1489 struct target_ucontext_v1 { 1490 abi_ulong tuc_flags; 1491 abi_ulong tuc_link; 1492 target_stack_t tuc_stack; 1493 struct target_sigcontext tuc_mcontext; 1494 target_sigset_t tuc_sigmask; /* mask last for extensibility */ 1495 }; 1496 1497 struct target_ucontext_v2 { 1498 abi_ulong tuc_flags; 1499 abi_ulong tuc_link; 1500 target_stack_t tuc_stack; 1501 struct target_sigcontext tuc_mcontext; 1502 target_sigset_t tuc_sigmask; /* mask last for extensibility */ 1503 char __unused[128 - sizeof(target_sigset_t)]; 1504 abi_ulong tuc_regspace[128] __attribute__((__aligned__(8))); 1505 }; 1506 1507 struct target_user_vfp { 1508 uint64_t fpregs[32]; 1509 abi_ulong fpscr; 1510 }; 1511 1512 struct target_user_vfp_exc { 1513 abi_ulong fpexc; 1514 abi_ulong fpinst; 1515 abi_ulong fpinst2; 1516 }; 1517 1518 struct target_vfp_sigframe { 1519 abi_ulong magic; 1520 abi_ulong size; 1521 struct target_user_vfp ufp; 1522 struct target_user_vfp_exc ufp_exc; 1523 } __attribute__((__aligned__(8))); 1524 1525 struct target_iwmmxt_sigframe { 1526 abi_ulong magic; 1527 abi_ulong size; 1528 uint64_t regs[16]; 1529 /* Note that not all the coprocessor control registers are stored here */ 1530 uint32_t wcssf; 1531 uint32_t wcasf; 1532 uint32_t wcgr0; 1533 uint32_t wcgr1; 1534 uint32_t wcgr2; 1535 uint32_t wcgr3; 1536 } __attribute__((__aligned__(8))); 1537 1538 #define TARGET_VFP_MAGIC 0x56465001 1539 #define TARGET_IWMMXT_MAGIC 0x12ef842a 1540 1541 struct sigframe_v1 1542 { 1543 struct target_sigcontext sc; 1544 abi_ulong extramask[TARGET_NSIG_WORDS-1]; 1545 abi_ulong retcode; 1546 }; 1547 1548 struct sigframe_v2 1549 { 1550 struct target_ucontext_v2 uc; 1551 abi_ulong retcode; 1552 }; 1553 1554 struct rt_sigframe_v1 1555 { 1556 abi_ulong pinfo; 1557 abi_ulong puc; 1558 struct target_siginfo info; 1559 struct target_ucontext_v1 uc; 1560 abi_ulong retcode; 1561 }; 1562 1563 struct rt_sigframe_v2 1564 { 1565 struct target_siginfo info; 1566 struct target_ucontext_v2 uc; 1567 abi_ulong retcode; 1568 }; 1569 1570 #define TARGET_CONFIG_CPU_32 1 1571 1572 /* 1573 * For ARM syscalls, we encode the syscall number into the instruction. 1574 */ 1575 #define SWI_SYS_SIGRETURN (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE)) 1576 #define SWI_SYS_RT_SIGRETURN (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE)) 1577 1578 /* 1579 * For Thumb syscalls, we pass the syscall number via r7. We therefore 1580 * need two 16-bit instructions. 1581 */ 1582 #define SWI_THUMB_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn)) 1583 #define SWI_THUMB_RT_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn)) 1584 1585 static const abi_ulong retcodes[4] = { 1586 SWI_SYS_SIGRETURN, SWI_THUMB_SIGRETURN, 1587 SWI_SYS_RT_SIGRETURN, SWI_THUMB_RT_SIGRETURN 1588 }; 1589 1590 1591 static inline int valid_user_regs(CPUARMState *regs) 1592 { 1593 return 1; 1594 } 1595 1596 static void 1597 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/ 1598 CPUARMState *env, abi_ulong mask) 1599 { 1600 __put_user(env->regs[0], &sc->arm_r0); 1601 __put_user(env->regs[1], &sc->arm_r1); 1602 __put_user(env->regs[2], &sc->arm_r2); 1603 __put_user(env->regs[3], &sc->arm_r3); 1604 __put_user(env->regs[4], &sc->arm_r4); 1605 __put_user(env->regs[5], &sc->arm_r5); 1606 __put_user(env->regs[6], &sc->arm_r6); 1607 __put_user(env->regs[7], &sc->arm_r7); 1608 __put_user(env->regs[8], &sc->arm_r8); 1609 __put_user(env->regs[9], &sc->arm_r9); 1610 __put_user(env->regs[10], &sc->arm_r10); 1611 __put_user(env->regs[11], &sc->arm_fp); 1612 __put_user(env->regs[12], &sc->arm_ip); 1613 __put_user(env->regs[13], &sc->arm_sp); 1614 __put_user(env->regs[14], &sc->arm_lr); 1615 __put_user(env->regs[15], &sc->arm_pc); 1616 #ifdef TARGET_CONFIG_CPU_32 1617 __put_user(cpsr_read(env), &sc->arm_cpsr); 1618 #endif 1619 1620 __put_user(/* current->thread.trap_no */ 0, &sc->trap_no); 1621 __put_user(/* current->thread.error_code */ 0, &sc->error_code); 1622 __put_user(/* current->thread.address */ 0, &sc->fault_address); 1623 __put_user(mask, &sc->oldmask); 1624 } 1625 1626 static inline abi_ulong 1627 get_sigframe(struct target_sigaction *ka, CPUARMState *regs, int framesize) 1628 { 1629 unsigned long sp = regs->regs[13]; 1630 1631 /* 1632 * This is the X/Open sanctioned signal stack switching. 1633 */ 1634 if ((ka->sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp)) { 1635 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 1636 } 1637 /* 1638 * ATPCS B01 mandates 8-byte alignment 1639 */ 1640 return (sp - framesize) & ~7; 1641 } 1642 1643 static void 1644 setup_return(CPUARMState *env, struct target_sigaction *ka, 1645 abi_ulong *rc, abi_ulong frame_addr, int usig, abi_ulong rc_addr) 1646 { 1647 abi_ulong handler = ka->_sa_handler; 1648 abi_ulong retcode; 1649 int thumb = handler & 1; 1650 uint32_t cpsr = cpsr_read(env); 1651 1652 cpsr &= ~CPSR_IT; 1653 if (thumb) { 1654 cpsr |= CPSR_T; 1655 } else { 1656 cpsr &= ~CPSR_T; 1657 } 1658 1659 if (ka->sa_flags & TARGET_SA_RESTORER) { 1660 retcode = ka->sa_restorer; 1661 } else { 1662 unsigned int idx = thumb; 1663 1664 if (ka->sa_flags & TARGET_SA_SIGINFO) { 1665 idx += 2; 1666 } 1667 1668 __put_user(retcodes[idx], rc); 1669 1670 retcode = rc_addr + thumb; 1671 } 1672 1673 env->regs[0] = usig; 1674 env->regs[13] = frame_addr; 1675 env->regs[14] = retcode; 1676 env->regs[15] = handler & (thumb ? ~1 : ~3); 1677 cpsr_write(env, cpsr, CPSR_IT | CPSR_T, CPSRWriteByInstr); 1678 } 1679 1680 static abi_ulong *setup_sigframe_v2_vfp(abi_ulong *regspace, CPUARMState *env) 1681 { 1682 int i; 1683 struct target_vfp_sigframe *vfpframe; 1684 vfpframe = (struct target_vfp_sigframe *)regspace; 1685 __put_user(TARGET_VFP_MAGIC, &vfpframe->magic); 1686 __put_user(sizeof(*vfpframe), &vfpframe->size); 1687 for (i = 0; i < 32; i++) { 1688 __put_user(float64_val(env->vfp.regs[i]), &vfpframe->ufp.fpregs[i]); 1689 } 1690 __put_user(vfp_get_fpscr(env), &vfpframe->ufp.fpscr); 1691 __put_user(env->vfp.xregs[ARM_VFP_FPEXC], &vfpframe->ufp_exc.fpexc); 1692 __put_user(env->vfp.xregs[ARM_VFP_FPINST], &vfpframe->ufp_exc.fpinst); 1693 __put_user(env->vfp.xregs[ARM_VFP_FPINST2], &vfpframe->ufp_exc.fpinst2); 1694 return (abi_ulong*)(vfpframe+1); 1695 } 1696 1697 static abi_ulong *setup_sigframe_v2_iwmmxt(abi_ulong *regspace, 1698 CPUARMState *env) 1699 { 1700 int i; 1701 struct target_iwmmxt_sigframe *iwmmxtframe; 1702 iwmmxtframe = (struct target_iwmmxt_sigframe *)regspace; 1703 __put_user(TARGET_IWMMXT_MAGIC, &iwmmxtframe->magic); 1704 __put_user(sizeof(*iwmmxtframe), &iwmmxtframe->size); 1705 for (i = 0; i < 16; i++) { 1706 __put_user(env->iwmmxt.regs[i], &iwmmxtframe->regs[i]); 1707 } 1708 __put_user(env->vfp.xregs[ARM_IWMMXT_wCSSF], &iwmmxtframe->wcssf); 1709 __put_user(env->vfp.xregs[ARM_IWMMXT_wCASF], &iwmmxtframe->wcssf); 1710 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR0], &iwmmxtframe->wcgr0); 1711 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR1], &iwmmxtframe->wcgr1); 1712 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR2], &iwmmxtframe->wcgr2); 1713 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR3], &iwmmxtframe->wcgr3); 1714 return (abi_ulong*)(iwmmxtframe+1); 1715 } 1716 1717 static void setup_sigframe_v2(struct target_ucontext_v2 *uc, 1718 target_sigset_t *set, CPUARMState *env) 1719 { 1720 struct target_sigaltstack stack; 1721 int i; 1722 abi_ulong *regspace; 1723 1724 /* Clear all the bits of the ucontext we don't use. */ 1725 memset(uc, 0, offsetof(struct target_ucontext_v2, tuc_mcontext)); 1726 1727 memset(&stack, 0, sizeof(stack)); 1728 __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp); 1729 __put_user(target_sigaltstack_used.ss_size, &stack.ss_size); 1730 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags); 1731 memcpy(&uc->tuc_stack, &stack, sizeof(stack)); 1732 1733 setup_sigcontext(&uc->tuc_mcontext, env, set->sig[0]); 1734 /* Save coprocessor signal frame. */ 1735 regspace = uc->tuc_regspace; 1736 if (arm_feature(env, ARM_FEATURE_VFP)) { 1737 regspace = setup_sigframe_v2_vfp(regspace, env); 1738 } 1739 if (arm_feature(env, ARM_FEATURE_IWMMXT)) { 1740 regspace = setup_sigframe_v2_iwmmxt(regspace, env); 1741 } 1742 1743 /* Write terminating magic word */ 1744 __put_user(0, regspace); 1745 1746 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 1747 __put_user(set->sig[i], &uc->tuc_sigmask.sig[i]); 1748 } 1749 } 1750 1751 /* compare linux/arch/arm/kernel/signal.c:setup_frame() */ 1752 static void setup_frame_v1(int usig, struct target_sigaction *ka, 1753 target_sigset_t *set, CPUARMState *regs) 1754 { 1755 struct sigframe_v1 *frame; 1756 abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame)); 1757 int i; 1758 1759 trace_user_setup_frame(regs, frame_addr); 1760 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 1761 return; 1762 } 1763 1764 setup_sigcontext(&frame->sc, regs, set->sig[0]); 1765 1766 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 1767 __put_user(set->sig[i], &frame->extramask[i - 1]); 1768 } 1769 1770 setup_return(regs, ka, &frame->retcode, frame_addr, usig, 1771 frame_addr + offsetof(struct sigframe_v1, retcode)); 1772 1773 unlock_user_struct(frame, frame_addr, 1); 1774 } 1775 1776 static void setup_frame_v2(int usig, struct target_sigaction *ka, 1777 target_sigset_t *set, CPUARMState *regs) 1778 { 1779 struct sigframe_v2 *frame; 1780 abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame)); 1781 1782 trace_user_setup_frame(regs, frame_addr); 1783 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 1784 return; 1785 } 1786 1787 setup_sigframe_v2(&frame->uc, set, regs); 1788 1789 setup_return(regs, ka, &frame->retcode, frame_addr, usig, 1790 frame_addr + offsetof(struct sigframe_v2, retcode)); 1791 1792 unlock_user_struct(frame, frame_addr, 1); 1793 } 1794 1795 static void setup_frame(int usig, struct target_sigaction *ka, 1796 target_sigset_t *set, CPUARMState *regs) 1797 { 1798 if (get_osversion() >= 0x020612) { 1799 setup_frame_v2(usig, ka, set, regs); 1800 } else { 1801 setup_frame_v1(usig, ka, set, regs); 1802 } 1803 } 1804 1805 /* compare linux/arch/arm/kernel/signal.c:setup_rt_frame() */ 1806 static void setup_rt_frame_v1(int usig, struct target_sigaction *ka, 1807 target_siginfo_t *info, 1808 target_sigset_t *set, CPUARMState *env) 1809 { 1810 struct rt_sigframe_v1 *frame; 1811 abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame)); 1812 struct target_sigaltstack stack; 1813 int i; 1814 abi_ulong info_addr, uc_addr; 1815 1816 trace_user_setup_rt_frame(env, frame_addr); 1817 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 1818 return /* 1 */; 1819 } 1820 1821 info_addr = frame_addr + offsetof(struct rt_sigframe_v1, info); 1822 __put_user(info_addr, &frame->pinfo); 1823 uc_addr = frame_addr + offsetof(struct rt_sigframe_v1, uc); 1824 __put_user(uc_addr, &frame->puc); 1825 tswap_siginfo(&frame->info, info); 1826 1827 /* Clear all the bits of the ucontext we don't use. */ 1828 memset(&frame->uc, 0, offsetof(struct target_ucontext_v1, tuc_mcontext)); 1829 1830 memset(&stack, 0, sizeof(stack)); 1831 __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp); 1832 __put_user(target_sigaltstack_used.ss_size, &stack.ss_size); 1833 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags); 1834 memcpy(&frame->uc.tuc_stack, &stack, sizeof(stack)); 1835 1836 setup_sigcontext(&frame->uc.tuc_mcontext, env, set->sig[0]); 1837 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 1838 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]); 1839 } 1840 1841 setup_return(env, ka, &frame->retcode, frame_addr, usig, 1842 frame_addr + offsetof(struct rt_sigframe_v1, retcode)); 1843 1844 env->regs[1] = info_addr; 1845 env->regs[2] = uc_addr; 1846 1847 unlock_user_struct(frame, frame_addr, 1); 1848 } 1849 1850 static void setup_rt_frame_v2(int usig, struct target_sigaction *ka, 1851 target_siginfo_t *info, 1852 target_sigset_t *set, CPUARMState *env) 1853 { 1854 struct rt_sigframe_v2 *frame; 1855 abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame)); 1856 abi_ulong info_addr, uc_addr; 1857 1858 trace_user_setup_rt_frame(env, frame_addr); 1859 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 1860 return /* 1 */; 1861 } 1862 1863 info_addr = frame_addr + offsetof(struct rt_sigframe_v2, info); 1864 uc_addr = frame_addr + offsetof(struct rt_sigframe_v2, uc); 1865 tswap_siginfo(&frame->info, info); 1866 1867 setup_sigframe_v2(&frame->uc, set, env); 1868 1869 setup_return(env, ka, &frame->retcode, frame_addr, usig, 1870 frame_addr + offsetof(struct rt_sigframe_v2, retcode)); 1871 1872 env->regs[1] = info_addr; 1873 env->regs[2] = uc_addr; 1874 1875 unlock_user_struct(frame, frame_addr, 1); 1876 } 1877 1878 static void setup_rt_frame(int usig, struct target_sigaction *ka, 1879 target_siginfo_t *info, 1880 target_sigset_t *set, CPUARMState *env) 1881 { 1882 if (get_osversion() >= 0x020612) { 1883 setup_rt_frame_v2(usig, ka, info, set, env); 1884 } else { 1885 setup_rt_frame_v1(usig, ka, info, set, env); 1886 } 1887 } 1888 1889 static int 1890 restore_sigcontext(CPUARMState *env, struct target_sigcontext *sc) 1891 { 1892 int err = 0; 1893 uint32_t cpsr; 1894 1895 __get_user(env->regs[0], &sc->arm_r0); 1896 __get_user(env->regs[1], &sc->arm_r1); 1897 __get_user(env->regs[2], &sc->arm_r2); 1898 __get_user(env->regs[3], &sc->arm_r3); 1899 __get_user(env->regs[4], &sc->arm_r4); 1900 __get_user(env->regs[5], &sc->arm_r5); 1901 __get_user(env->regs[6], &sc->arm_r6); 1902 __get_user(env->regs[7], &sc->arm_r7); 1903 __get_user(env->regs[8], &sc->arm_r8); 1904 __get_user(env->regs[9], &sc->arm_r9); 1905 __get_user(env->regs[10], &sc->arm_r10); 1906 __get_user(env->regs[11], &sc->arm_fp); 1907 __get_user(env->regs[12], &sc->arm_ip); 1908 __get_user(env->regs[13], &sc->arm_sp); 1909 __get_user(env->regs[14], &sc->arm_lr); 1910 __get_user(env->regs[15], &sc->arm_pc); 1911 #ifdef TARGET_CONFIG_CPU_32 1912 __get_user(cpsr, &sc->arm_cpsr); 1913 cpsr_write(env, cpsr, CPSR_USER | CPSR_EXEC, CPSRWriteByInstr); 1914 #endif 1915 1916 err |= !valid_user_regs(env); 1917 1918 return err; 1919 } 1920 1921 static long do_sigreturn_v1(CPUARMState *env) 1922 { 1923 abi_ulong frame_addr; 1924 struct sigframe_v1 *frame = NULL; 1925 target_sigset_t set; 1926 sigset_t host_set; 1927 int i; 1928 1929 /* 1930 * Since we stacked the signal on a 64-bit boundary, 1931 * then 'sp' should be word aligned here. If it's 1932 * not, then the user is trying to mess with us. 1933 */ 1934 frame_addr = env->regs[13]; 1935 trace_user_do_sigreturn(env, frame_addr); 1936 if (frame_addr & 7) { 1937 goto badframe; 1938 } 1939 1940 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) { 1941 goto badframe; 1942 } 1943 1944 __get_user(set.sig[0], &frame->sc.oldmask); 1945 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 1946 __get_user(set.sig[i], &frame->extramask[i - 1]); 1947 } 1948 1949 target_to_host_sigset_internal(&host_set, &set); 1950 set_sigmask(&host_set); 1951 1952 if (restore_sigcontext(env, &frame->sc)) { 1953 goto badframe; 1954 } 1955 1956 #if 0 1957 /* Send SIGTRAP if we're single-stepping */ 1958 if (ptrace_cancel_bpt(current)) 1959 send_sig(SIGTRAP, current, 1); 1960 #endif 1961 unlock_user_struct(frame, frame_addr, 0); 1962 return -TARGET_QEMU_ESIGRETURN; 1963 1964 badframe: 1965 force_sig(TARGET_SIGSEGV /* , current */); 1966 return 0; 1967 } 1968 1969 static abi_ulong *restore_sigframe_v2_vfp(CPUARMState *env, abi_ulong *regspace) 1970 { 1971 int i; 1972 abi_ulong magic, sz; 1973 uint32_t fpscr, fpexc; 1974 struct target_vfp_sigframe *vfpframe; 1975 vfpframe = (struct target_vfp_sigframe *)regspace; 1976 1977 __get_user(magic, &vfpframe->magic); 1978 __get_user(sz, &vfpframe->size); 1979 if (magic != TARGET_VFP_MAGIC || sz != sizeof(*vfpframe)) { 1980 return 0; 1981 } 1982 for (i = 0; i < 32; i++) { 1983 __get_user(float64_val(env->vfp.regs[i]), &vfpframe->ufp.fpregs[i]); 1984 } 1985 __get_user(fpscr, &vfpframe->ufp.fpscr); 1986 vfp_set_fpscr(env, fpscr); 1987 __get_user(fpexc, &vfpframe->ufp_exc.fpexc); 1988 /* Sanitise FPEXC: ensure VFP is enabled, FPINST2 is invalid 1989 * and the exception flag is cleared 1990 */ 1991 fpexc |= (1 << 30); 1992 fpexc &= ~((1 << 31) | (1 << 28)); 1993 env->vfp.xregs[ARM_VFP_FPEXC] = fpexc; 1994 __get_user(env->vfp.xregs[ARM_VFP_FPINST], &vfpframe->ufp_exc.fpinst); 1995 __get_user(env->vfp.xregs[ARM_VFP_FPINST2], &vfpframe->ufp_exc.fpinst2); 1996 return (abi_ulong*)(vfpframe + 1); 1997 } 1998 1999 static abi_ulong *restore_sigframe_v2_iwmmxt(CPUARMState *env, 2000 abi_ulong *regspace) 2001 { 2002 int i; 2003 abi_ulong magic, sz; 2004 struct target_iwmmxt_sigframe *iwmmxtframe; 2005 iwmmxtframe = (struct target_iwmmxt_sigframe *)regspace; 2006 2007 __get_user(magic, &iwmmxtframe->magic); 2008 __get_user(sz, &iwmmxtframe->size); 2009 if (magic != TARGET_IWMMXT_MAGIC || sz != sizeof(*iwmmxtframe)) { 2010 return 0; 2011 } 2012 for (i = 0; i < 16; i++) { 2013 __get_user(env->iwmmxt.regs[i], &iwmmxtframe->regs[i]); 2014 } 2015 __get_user(env->vfp.xregs[ARM_IWMMXT_wCSSF], &iwmmxtframe->wcssf); 2016 __get_user(env->vfp.xregs[ARM_IWMMXT_wCASF], &iwmmxtframe->wcssf); 2017 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR0], &iwmmxtframe->wcgr0); 2018 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR1], &iwmmxtframe->wcgr1); 2019 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR2], &iwmmxtframe->wcgr2); 2020 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR3], &iwmmxtframe->wcgr3); 2021 return (abi_ulong*)(iwmmxtframe + 1); 2022 } 2023 2024 static int do_sigframe_return_v2(CPUARMState *env, target_ulong frame_addr, 2025 struct target_ucontext_v2 *uc) 2026 { 2027 sigset_t host_set; 2028 abi_ulong *regspace; 2029 2030 target_to_host_sigset(&host_set, &uc->tuc_sigmask); 2031 set_sigmask(&host_set); 2032 2033 if (restore_sigcontext(env, &uc->tuc_mcontext)) 2034 return 1; 2035 2036 /* Restore coprocessor signal frame */ 2037 regspace = uc->tuc_regspace; 2038 if (arm_feature(env, ARM_FEATURE_VFP)) { 2039 regspace = restore_sigframe_v2_vfp(env, regspace); 2040 if (!regspace) { 2041 return 1; 2042 } 2043 } 2044 if (arm_feature(env, ARM_FEATURE_IWMMXT)) { 2045 regspace = restore_sigframe_v2_iwmmxt(env, regspace); 2046 if (!regspace) { 2047 return 1; 2048 } 2049 } 2050 2051 if (do_sigaltstack(frame_addr + offsetof(struct target_ucontext_v2, tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT) 2052 return 1; 2053 2054 #if 0 2055 /* Send SIGTRAP if we're single-stepping */ 2056 if (ptrace_cancel_bpt(current)) 2057 send_sig(SIGTRAP, current, 1); 2058 #endif 2059 2060 return 0; 2061 } 2062 2063 static long do_sigreturn_v2(CPUARMState *env) 2064 { 2065 abi_ulong frame_addr; 2066 struct sigframe_v2 *frame = NULL; 2067 2068 /* 2069 * Since we stacked the signal on a 64-bit boundary, 2070 * then 'sp' should be word aligned here. If it's 2071 * not, then the user is trying to mess with us. 2072 */ 2073 frame_addr = env->regs[13]; 2074 trace_user_do_sigreturn(env, frame_addr); 2075 if (frame_addr & 7) { 2076 goto badframe; 2077 } 2078 2079 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) { 2080 goto badframe; 2081 } 2082 2083 if (do_sigframe_return_v2(env, frame_addr, &frame->uc)) { 2084 goto badframe; 2085 } 2086 2087 unlock_user_struct(frame, frame_addr, 0); 2088 return -TARGET_QEMU_ESIGRETURN; 2089 2090 badframe: 2091 unlock_user_struct(frame, frame_addr, 0); 2092 force_sig(TARGET_SIGSEGV /* , current */); 2093 return 0; 2094 } 2095 2096 long do_sigreturn(CPUARMState *env) 2097 { 2098 if (get_osversion() >= 0x020612) { 2099 return do_sigreturn_v2(env); 2100 } else { 2101 return do_sigreturn_v1(env); 2102 } 2103 } 2104 2105 static long do_rt_sigreturn_v1(CPUARMState *env) 2106 { 2107 abi_ulong frame_addr; 2108 struct rt_sigframe_v1 *frame = NULL; 2109 sigset_t host_set; 2110 2111 /* 2112 * Since we stacked the signal on a 64-bit boundary, 2113 * then 'sp' should be word aligned here. If it's 2114 * not, then the user is trying to mess with us. 2115 */ 2116 frame_addr = env->regs[13]; 2117 trace_user_do_rt_sigreturn(env, frame_addr); 2118 if (frame_addr & 7) { 2119 goto badframe; 2120 } 2121 2122 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) { 2123 goto badframe; 2124 } 2125 2126 target_to_host_sigset(&host_set, &frame->uc.tuc_sigmask); 2127 set_sigmask(&host_set); 2128 2129 if (restore_sigcontext(env, &frame->uc.tuc_mcontext)) { 2130 goto badframe; 2131 } 2132 2133 if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe_v1, uc.tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT) 2134 goto badframe; 2135 2136 #if 0 2137 /* Send SIGTRAP if we're single-stepping */ 2138 if (ptrace_cancel_bpt(current)) 2139 send_sig(SIGTRAP, current, 1); 2140 #endif 2141 unlock_user_struct(frame, frame_addr, 0); 2142 return -TARGET_QEMU_ESIGRETURN; 2143 2144 badframe: 2145 unlock_user_struct(frame, frame_addr, 0); 2146 force_sig(TARGET_SIGSEGV /* , current */); 2147 return 0; 2148 } 2149 2150 static long do_rt_sigreturn_v2(CPUARMState *env) 2151 { 2152 abi_ulong frame_addr; 2153 struct rt_sigframe_v2 *frame = NULL; 2154 2155 /* 2156 * Since we stacked the signal on a 64-bit boundary, 2157 * then 'sp' should be word aligned here. If it's 2158 * not, then the user is trying to mess with us. 2159 */ 2160 frame_addr = env->regs[13]; 2161 trace_user_do_rt_sigreturn(env, frame_addr); 2162 if (frame_addr & 7) { 2163 goto badframe; 2164 } 2165 2166 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) { 2167 goto badframe; 2168 } 2169 2170 if (do_sigframe_return_v2(env, frame_addr, &frame->uc)) { 2171 goto badframe; 2172 } 2173 2174 unlock_user_struct(frame, frame_addr, 0); 2175 return -TARGET_QEMU_ESIGRETURN; 2176 2177 badframe: 2178 unlock_user_struct(frame, frame_addr, 0); 2179 force_sig(TARGET_SIGSEGV /* , current */); 2180 return 0; 2181 } 2182 2183 long do_rt_sigreturn(CPUARMState *env) 2184 { 2185 if (get_osversion() >= 0x020612) { 2186 return do_rt_sigreturn_v2(env); 2187 } else { 2188 return do_rt_sigreturn_v1(env); 2189 } 2190 } 2191 2192 #elif defined(TARGET_SPARC) 2193 2194 #define __SUNOS_MAXWIN 31 2195 2196 /* This is what SunOS does, so shall I. */ 2197 struct target_sigcontext { 2198 abi_ulong sigc_onstack; /* state to restore */ 2199 2200 abi_ulong sigc_mask; /* sigmask to restore */ 2201 abi_ulong sigc_sp; /* stack pointer */ 2202 abi_ulong sigc_pc; /* program counter */ 2203 abi_ulong sigc_npc; /* next program counter */ 2204 abi_ulong sigc_psr; /* for condition codes etc */ 2205 abi_ulong sigc_g1; /* User uses these two registers */ 2206 abi_ulong sigc_o0; /* within the trampoline code. */ 2207 2208 /* Now comes information regarding the users window set 2209 * at the time of the signal. 2210 */ 2211 abi_ulong sigc_oswins; /* outstanding windows */ 2212 2213 /* stack ptrs for each regwin buf */ 2214 char *sigc_spbuf[__SUNOS_MAXWIN]; 2215 2216 /* Windows to restore after signal */ 2217 struct { 2218 abi_ulong locals[8]; 2219 abi_ulong ins[8]; 2220 } sigc_wbuf[__SUNOS_MAXWIN]; 2221 }; 2222 /* A Sparc stack frame */ 2223 struct sparc_stackf { 2224 abi_ulong locals[8]; 2225 abi_ulong ins[8]; 2226 /* It's simpler to treat fp and callers_pc as elements of ins[] 2227 * since we never need to access them ourselves. 2228 */ 2229 char *structptr; 2230 abi_ulong xargs[6]; 2231 abi_ulong xxargs[1]; 2232 }; 2233 2234 typedef struct { 2235 struct { 2236 abi_ulong psr; 2237 abi_ulong pc; 2238 abi_ulong npc; 2239 abi_ulong y; 2240 abi_ulong u_regs[16]; /* globals and ins */ 2241 } si_regs; 2242 int si_mask; 2243 } __siginfo_t; 2244 2245 typedef struct { 2246 abi_ulong si_float_regs[32]; 2247 unsigned long si_fsr; 2248 unsigned long si_fpqdepth; 2249 struct { 2250 unsigned long *insn_addr; 2251 unsigned long insn; 2252 } si_fpqueue [16]; 2253 } qemu_siginfo_fpu_t; 2254 2255 2256 struct target_signal_frame { 2257 struct sparc_stackf ss; 2258 __siginfo_t info; 2259 abi_ulong fpu_save; 2260 abi_ulong insns[2] __attribute__ ((aligned (8))); 2261 abi_ulong extramask[TARGET_NSIG_WORDS - 1]; 2262 abi_ulong extra_size; /* Should be 0 */ 2263 qemu_siginfo_fpu_t fpu_state; 2264 }; 2265 struct target_rt_signal_frame { 2266 struct sparc_stackf ss; 2267 siginfo_t info; 2268 abi_ulong regs[20]; 2269 sigset_t mask; 2270 abi_ulong fpu_save; 2271 unsigned int insns[2]; 2272 stack_t stack; 2273 unsigned int extra_size; /* Should be 0 */ 2274 qemu_siginfo_fpu_t fpu_state; 2275 }; 2276 2277 #define UREG_O0 16 2278 #define UREG_O6 22 2279 #define UREG_I0 0 2280 #define UREG_I1 1 2281 #define UREG_I2 2 2282 #define UREG_I3 3 2283 #define UREG_I4 4 2284 #define UREG_I5 5 2285 #define UREG_I6 6 2286 #define UREG_I7 7 2287 #define UREG_L0 8 2288 #define UREG_FP UREG_I6 2289 #define UREG_SP UREG_O6 2290 2291 static inline abi_ulong get_sigframe(struct target_sigaction *sa, 2292 CPUSPARCState *env, 2293 unsigned long framesize) 2294 { 2295 abi_ulong sp; 2296 2297 sp = env->regwptr[UREG_FP]; 2298 2299 /* This is the X/Open sanctioned signal stack switching. */ 2300 if (sa->sa_flags & TARGET_SA_ONSTACK) { 2301 if (!on_sig_stack(sp) 2302 && !((target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size) & 7)) { 2303 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 2304 } 2305 } 2306 return sp - framesize; 2307 } 2308 2309 static int 2310 setup___siginfo(__siginfo_t *si, CPUSPARCState *env, abi_ulong mask) 2311 { 2312 int err = 0, i; 2313 2314 __put_user(env->psr, &si->si_regs.psr); 2315 __put_user(env->pc, &si->si_regs.pc); 2316 __put_user(env->npc, &si->si_regs.npc); 2317 __put_user(env->y, &si->si_regs.y); 2318 for (i=0; i < 8; i++) { 2319 __put_user(env->gregs[i], &si->si_regs.u_regs[i]); 2320 } 2321 for (i=0; i < 8; i++) { 2322 __put_user(env->regwptr[UREG_I0 + i], &si->si_regs.u_regs[i+8]); 2323 } 2324 __put_user(mask, &si->si_mask); 2325 return err; 2326 } 2327 2328 #if 0 2329 static int 2330 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/ 2331 CPUSPARCState *env, unsigned long mask) 2332 { 2333 int err = 0; 2334 2335 __put_user(mask, &sc->sigc_mask); 2336 __put_user(env->regwptr[UREG_SP], &sc->sigc_sp); 2337 __put_user(env->pc, &sc->sigc_pc); 2338 __put_user(env->npc, &sc->sigc_npc); 2339 __put_user(env->psr, &sc->sigc_psr); 2340 __put_user(env->gregs[1], &sc->sigc_g1); 2341 __put_user(env->regwptr[UREG_O0], &sc->sigc_o0); 2342 2343 return err; 2344 } 2345 #endif 2346 #define NF_ALIGNEDSZ (((sizeof(struct target_signal_frame) + 7) & (~7))) 2347 2348 static void setup_frame(int sig, struct target_sigaction *ka, 2349 target_sigset_t *set, CPUSPARCState *env) 2350 { 2351 abi_ulong sf_addr; 2352 struct target_signal_frame *sf; 2353 int sigframe_size, err, i; 2354 2355 /* 1. Make sure everything is clean */ 2356 //synchronize_user_stack(); 2357 2358 sigframe_size = NF_ALIGNEDSZ; 2359 sf_addr = get_sigframe(ka, env, sigframe_size); 2360 trace_user_setup_frame(env, sf_addr); 2361 2362 sf = lock_user(VERIFY_WRITE, sf_addr, 2363 sizeof(struct target_signal_frame), 0); 2364 if (!sf) { 2365 goto sigsegv; 2366 } 2367 #if 0 2368 if (invalid_frame_pointer(sf, sigframe_size)) 2369 goto sigill_and_return; 2370 #endif 2371 /* 2. Save the current process state */ 2372 err = setup___siginfo(&sf->info, env, set->sig[0]); 2373 __put_user(0, &sf->extra_size); 2374 2375 //save_fpu_state(regs, &sf->fpu_state); 2376 //__put_user(&sf->fpu_state, &sf->fpu_save); 2377 2378 __put_user(set->sig[0], &sf->info.si_mask); 2379 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) { 2380 __put_user(set->sig[i + 1], &sf->extramask[i]); 2381 } 2382 2383 for (i = 0; i < 8; i++) { 2384 __put_user(env->regwptr[i + UREG_L0], &sf->ss.locals[i]); 2385 } 2386 for (i = 0; i < 8; i++) { 2387 __put_user(env->regwptr[i + UREG_I0], &sf->ss.ins[i]); 2388 } 2389 if (err) 2390 goto sigsegv; 2391 2392 /* 3. signal handler back-trampoline and parameters */ 2393 env->regwptr[UREG_FP] = sf_addr; 2394 env->regwptr[UREG_I0] = sig; 2395 env->regwptr[UREG_I1] = sf_addr + 2396 offsetof(struct target_signal_frame, info); 2397 env->regwptr[UREG_I2] = sf_addr + 2398 offsetof(struct target_signal_frame, info); 2399 2400 /* 4. signal handler */ 2401 env->pc = ka->_sa_handler; 2402 env->npc = (env->pc + 4); 2403 /* 5. return to kernel instructions */ 2404 if (ka->sa_restorer) { 2405 env->regwptr[UREG_I7] = ka->sa_restorer; 2406 } else { 2407 uint32_t val32; 2408 2409 env->regwptr[UREG_I7] = sf_addr + 2410 offsetof(struct target_signal_frame, insns) - 2 * 4; 2411 2412 /* mov __NR_sigreturn, %g1 */ 2413 val32 = 0x821020d8; 2414 __put_user(val32, &sf->insns[0]); 2415 2416 /* t 0x10 */ 2417 val32 = 0x91d02010; 2418 __put_user(val32, &sf->insns[1]); 2419 if (err) 2420 goto sigsegv; 2421 2422 /* Flush instruction space. */ 2423 // flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0])); 2424 // tb_flush(env); 2425 } 2426 unlock_user(sf, sf_addr, sizeof(struct target_signal_frame)); 2427 return; 2428 #if 0 2429 sigill_and_return: 2430 force_sig(TARGET_SIGILL); 2431 #endif 2432 sigsegv: 2433 unlock_user(sf, sf_addr, sizeof(struct target_signal_frame)); 2434 force_sig(TARGET_SIGSEGV); 2435 } 2436 2437 static void setup_rt_frame(int sig, struct target_sigaction *ka, 2438 target_siginfo_t *info, 2439 target_sigset_t *set, CPUSPARCState *env) 2440 { 2441 fprintf(stderr, "setup_rt_frame: not implemented\n"); 2442 } 2443 2444 long do_sigreturn(CPUSPARCState *env) 2445 { 2446 abi_ulong sf_addr; 2447 struct target_signal_frame *sf; 2448 uint32_t up_psr, pc, npc; 2449 target_sigset_t set; 2450 sigset_t host_set; 2451 int err=0, i; 2452 2453 sf_addr = env->regwptr[UREG_FP]; 2454 trace_user_do_sigreturn(env, sf_addr); 2455 if (!lock_user_struct(VERIFY_READ, sf, sf_addr, 1)) { 2456 goto segv_and_exit; 2457 } 2458 2459 /* 1. Make sure we are not getting garbage from the user */ 2460 2461 if (sf_addr & 3) 2462 goto segv_and_exit; 2463 2464 __get_user(pc, &sf->info.si_regs.pc); 2465 __get_user(npc, &sf->info.si_regs.npc); 2466 2467 if ((pc | npc) & 3) { 2468 goto segv_and_exit; 2469 } 2470 2471 /* 2. Restore the state */ 2472 __get_user(up_psr, &sf->info.si_regs.psr); 2473 2474 /* User can only change condition codes and FPU enabling in %psr. */ 2475 env->psr = (up_psr & (PSR_ICC /* | PSR_EF */)) 2476 | (env->psr & ~(PSR_ICC /* | PSR_EF */)); 2477 2478 env->pc = pc; 2479 env->npc = npc; 2480 __get_user(env->y, &sf->info.si_regs.y); 2481 for (i=0; i < 8; i++) { 2482 __get_user(env->gregs[i], &sf->info.si_regs.u_regs[i]); 2483 } 2484 for (i=0; i < 8; i++) { 2485 __get_user(env->regwptr[i + UREG_I0], &sf->info.si_regs.u_regs[i+8]); 2486 } 2487 2488 /* FIXME: implement FPU save/restore: 2489 * __get_user(fpu_save, &sf->fpu_save); 2490 * if (fpu_save) 2491 * err |= restore_fpu_state(env, fpu_save); 2492 */ 2493 2494 /* This is pretty much atomic, no amount locking would prevent 2495 * the races which exist anyways. 2496 */ 2497 __get_user(set.sig[0], &sf->info.si_mask); 2498 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 2499 __get_user(set.sig[i], &sf->extramask[i - 1]); 2500 } 2501 2502 target_to_host_sigset_internal(&host_set, &set); 2503 set_sigmask(&host_set); 2504 2505 if (err) { 2506 goto segv_and_exit; 2507 } 2508 unlock_user_struct(sf, sf_addr, 0); 2509 return -TARGET_QEMU_ESIGRETURN; 2510 2511 segv_and_exit: 2512 unlock_user_struct(sf, sf_addr, 0); 2513 force_sig(TARGET_SIGSEGV); 2514 } 2515 2516 long do_rt_sigreturn(CPUSPARCState *env) 2517 { 2518 trace_user_do_rt_sigreturn(env, 0); 2519 fprintf(stderr, "do_rt_sigreturn: not implemented\n"); 2520 return -TARGET_ENOSYS; 2521 } 2522 2523 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32) 2524 #define MC_TSTATE 0 2525 #define MC_PC 1 2526 #define MC_NPC 2 2527 #define MC_Y 3 2528 #define MC_G1 4 2529 #define MC_G2 5 2530 #define MC_G3 6 2531 #define MC_G4 7 2532 #define MC_G5 8 2533 #define MC_G6 9 2534 #define MC_G7 10 2535 #define MC_O0 11 2536 #define MC_O1 12 2537 #define MC_O2 13 2538 #define MC_O3 14 2539 #define MC_O4 15 2540 #define MC_O5 16 2541 #define MC_O6 17 2542 #define MC_O7 18 2543 #define MC_NGREG 19 2544 2545 typedef abi_ulong target_mc_greg_t; 2546 typedef target_mc_greg_t target_mc_gregset_t[MC_NGREG]; 2547 2548 struct target_mc_fq { 2549 abi_ulong *mcfq_addr; 2550 uint32_t mcfq_insn; 2551 }; 2552 2553 struct target_mc_fpu { 2554 union { 2555 uint32_t sregs[32]; 2556 uint64_t dregs[32]; 2557 //uint128_t qregs[16]; 2558 } mcfpu_fregs; 2559 abi_ulong mcfpu_fsr; 2560 abi_ulong mcfpu_fprs; 2561 abi_ulong mcfpu_gsr; 2562 struct target_mc_fq *mcfpu_fq; 2563 unsigned char mcfpu_qcnt; 2564 unsigned char mcfpu_qentsz; 2565 unsigned char mcfpu_enab; 2566 }; 2567 typedef struct target_mc_fpu target_mc_fpu_t; 2568 2569 typedef struct { 2570 target_mc_gregset_t mc_gregs; 2571 target_mc_greg_t mc_fp; 2572 target_mc_greg_t mc_i7; 2573 target_mc_fpu_t mc_fpregs; 2574 } target_mcontext_t; 2575 2576 struct target_ucontext { 2577 struct target_ucontext *tuc_link; 2578 abi_ulong tuc_flags; 2579 target_sigset_t tuc_sigmask; 2580 target_mcontext_t tuc_mcontext; 2581 }; 2582 2583 /* A V9 register window */ 2584 struct target_reg_window { 2585 abi_ulong locals[8]; 2586 abi_ulong ins[8]; 2587 }; 2588 2589 #define TARGET_STACK_BIAS 2047 2590 2591 /* {set, get}context() needed for 64-bit SparcLinux userland. */ 2592 void sparc64_set_context(CPUSPARCState *env) 2593 { 2594 abi_ulong ucp_addr; 2595 struct target_ucontext *ucp; 2596 target_mc_gregset_t *grp; 2597 abi_ulong pc, npc, tstate; 2598 abi_ulong fp, i7, w_addr; 2599 unsigned int i; 2600 2601 ucp_addr = env->regwptr[UREG_I0]; 2602 if (!lock_user_struct(VERIFY_READ, ucp, ucp_addr, 1)) { 2603 goto do_sigsegv; 2604 } 2605 grp = &ucp->tuc_mcontext.mc_gregs; 2606 __get_user(pc, &((*grp)[MC_PC])); 2607 __get_user(npc, &((*grp)[MC_NPC])); 2608 if ((pc | npc) & 3) { 2609 goto do_sigsegv; 2610 } 2611 if (env->regwptr[UREG_I1]) { 2612 target_sigset_t target_set; 2613 sigset_t set; 2614 2615 if (TARGET_NSIG_WORDS == 1) { 2616 __get_user(target_set.sig[0], &ucp->tuc_sigmask.sig[0]); 2617 } else { 2618 abi_ulong *src, *dst; 2619 src = ucp->tuc_sigmask.sig; 2620 dst = target_set.sig; 2621 for (i = 0; i < TARGET_NSIG_WORDS; i++, dst++, src++) { 2622 __get_user(*dst, src); 2623 } 2624 } 2625 target_to_host_sigset_internal(&set, &target_set); 2626 set_sigmask(&set); 2627 } 2628 env->pc = pc; 2629 env->npc = npc; 2630 __get_user(env->y, &((*grp)[MC_Y])); 2631 __get_user(tstate, &((*grp)[MC_TSTATE])); 2632 env->asi = (tstate >> 24) & 0xff; 2633 cpu_put_ccr(env, tstate >> 32); 2634 cpu_put_cwp64(env, tstate & 0x1f); 2635 __get_user(env->gregs[1], (&(*grp)[MC_G1])); 2636 __get_user(env->gregs[2], (&(*grp)[MC_G2])); 2637 __get_user(env->gregs[3], (&(*grp)[MC_G3])); 2638 __get_user(env->gregs[4], (&(*grp)[MC_G4])); 2639 __get_user(env->gregs[5], (&(*grp)[MC_G5])); 2640 __get_user(env->gregs[6], (&(*grp)[MC_G6])); 2641 __get_user(env->gregs[7], (&(*grp)[MC_G7])); 2642 __get_user(env->regwptr[UREG_I0], (&(*grp)[MC_O0])); 2643 __get_user(env->regwptr[UREG_I1], (&(*grp)[MC_O1])); 2644 __get_user(env->regwptr[UREG_I2], (&(*grp)[MC_O2])); 2645 __get_user(env->regwptr[UREG_I3], (&(*grp)[MC_O3])); 2646 __get_user(env->regwptr[UREG_I4], (&(*grp)[MC_O4])); 2647 __get_user(env->regwptr[UREG_I5], (&(*grp)[MC_O5])); 2648 __get_user(env->regwptr[UREG_I6], (&(*grp)[MC_O6])); 2649 __get_user(env->regwptr[UREG_I7], (&(*grp)[MC_O7])); 2650 2651 __get_user(fp, &(ucp->tuc_mcontext.mc_fp)); 2652 __get_user(i7, &(ucp->tuc_mcontext.mc_i7)); 2653 2654 w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6]; 2655 if (put_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]), 2656 abi_ulong) != 0) { 2657 goto do_sigsegv; 2658 } 2659 if (put_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]), 2660 abi_ulong) != 0) { 2661 goto do_sigsegv; 2662 } 2663 /* FIXME this does not match how the kernel handles the FPU in 2664 * its sparc64_set_context implementation. In particular the FPU 2665 * is only restored if fenab is non-zero in: 2666 * __get_user(fenab, &(ucp->tuc_mcontext.mc_fpregs.mcfpu_enab)); 2667 */ 2668 __get_user(env->fprs, &(ucp->tuc_mcontext.mc_fpregs.mcfpu_fprs)); 2669 { 2670 uint32_t *src = ucp->tuc_mcontext.mc_fpregs.mcfpu_fregs.sregs; 2671 for (i = 0; i < 64; i++, src++) { 2672 if (i & 1) { 2673 __get_user(env->fpr[i/2].l.lower, src); 2674 } else { 2675 __get_user(env->fpr[i/2].l.upper, src); 2676 } 2677 } 2678 } 2679 __get_user(env->fsr, 2680 &(ucp->tuc_mcontext.mc_fpregs.mcfpu_fsr)); 2681 __get_user(env->gsr, 2682 &(ucp->tuc_mcontext.mc_fpregs.mcfpu_gsr)); 2683 unlock_user_struct(ucp, ucp_addr, 0); 2684 return; 2685 do_sigsegv: 2686 unlock_user_struct(ucp, ucp_addr, 0); 2687 force_sig(TARGET_SIGSEGV); 2688 } 2689 2690 void sparc64_get_context(CPUSPARCState *env) 2691 { 2692 abi_ulong ucp_addr; 2693 struct target_ucontext *ucp; 2694 target_mc_gregset_t *grp; 2695 target_mcontext_t *mcp; 2696 abi_ulong fp, i7, w_addr; 2697 int err; 2698 unsigned int i; 2699 target_sigset_t target_set; 2700 sigset_t set; 2701 2702 ucp_addr = env->regwptr[UREG_I0]; 2703 if (!lock_user_struct(VERIFY_WRITE, ucp, ucp_addr, 0)) { 2704 goto do_sigsegv; 2705 } 2706 2707 mcp = &ucp->tuc_mcontext; 2708 grp = &mcp->mc_gregs; 2709 2710 /* Skip over the trap instruction, first. */ 2711 env->pc = env->npc; 2712 env->npc += 4; 2713 2714 /* If we're only reading the signal mask then do_sigprocmask() 2715 * is guaranteed not to fail, which is important because we don't 2716 * have any way to signal a failure or restart this operation since 2717 * this is not a normal syscall. 2718 */ 2719 err = do_sigprocmask(0, NULL, &set); 2720 assert(err == 0); 2721 host_to_target_sigset_internal(&target_set, &set); 2722 if (TARGET_NSIG_WORDS == 1) { 2723 __put_user(target_set.sig[0], 2724 (abi_ulong *)&ucp->tuc_sigmask); 2725 } else { 2726 abi_ulong *src, *dst; 2727 src = target_set.sig; 2728 dst = ucp->tuc_sigmask.sig; 2729 for (i = 0; i < TARGET_NSIG_WORDS; i++, dst++, src++) { 2730 __put_user(*src, dst); 2731 } 2732 if (err) 2733 goto do_sigsegv; 2734 } 2735 2736 /* XXX: tstate must be saved properly */ 2737 // __put_user(env->tstate, &((*grp)[MC_TSTATE])); 2738 __put_user(env->pc, &((*grp)[MC_PC])); 2739 __put_user(env->npc, &((*grp)[MC_NPC])); 2740 __put_user(env->y, &((*grp)[MC_Y])); 2741 __put_user(env->gregs[1], &((*grp)[MC_G1])); 2742 __put_user(env->gregs[2], &((*grp)[MC_G2])); 2743 __put_user(env->gregs[3], &((*grp)[MC_G3])); 2744 __put_user(env->gregs[4], &((*grp)[MC_G4])); 2745 __put_user(env->gregs[5], &((*grp)[MC_G5])); 2746 __put_user(env->gregs[6], &((*grp)[MC_G6])); 2747 __put_user(env->gregs[7], &((*grp)[MC_G7])); 2748 __put_user(env->regwptr[UREG_I0], &((*grp)[MC_O0])); 2749 __put_user(env->regwptr[UREG_I1], &((*grp)[MC_O1])); 2750 __put_user(env->regwptr[UREG_I2], &((*grp)[MC_O2])); 2751 __put_user(env->regwptr[UREG_I3], &((*grp)[MC_O3])); 2752 __put_user(env->regwptr[UREG_I4], &((*grp)[MC_O4])); 2753 __put_user(env->regwptr[UREG_I5], &((*grp)[MC_O5])); 2754 __put_user(env->regwptr[UREG_I6], &((*grp)[MC_O6])); 2755 __put_user(env->regwptr[UREG_I7], &((*grp)[MC_O7])); 2756 2757 w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6]; 2758 fp = i7 = 0; 2759 if (get_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]), 2760 abi_ulong) != 0) { 2761 goto do_sigsegv; 2762 } 2763 if (get_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]), 2764 abi_ulong) != 0) { 2765 goto do_sigsegv; 2766 } 2767 __put_user(fp, &(mcp->mc_fp)); 2768 __put_user(i7, &(mcp->mc_i7)); 2769 2770 { 2771 uint32_t *dst = ucp->tuc_mcontext.mc_fpregs.mcfpu_fregs.sregs; 2772 for (i = 0; i < 64; i++, dst++) { 2773 if (i & 1) { 2774 __put_user(env->fpr[i/2].l.lower, dst); 2775 } else { 2776 __put_user(env->fpr[i/2].l.upper, dst); 2777 } 2778 } 2779 } 2780 __put_user(env->fsr, &(mcp->mc_fpregs.mcfpu_fsr)); 2781 __put_user(env->gsr, &(mcp->mc_fpregs.mcfpu_gsr)); 2782 __put_user(env->fprs, &(mcp->mc_fpregs.mcfpu_fprs)); 2783 2784 if (err) 2785 goto do_sigsegv; 2786 unlock_user_struct(ucp, ucp_addr, 1); 2787 return; 2788 do_sigsegv: 2789 unlock_user_struct(ucp, ucp_addr, 1); 2790 force_sig(TARGET_SIGSEGV); 2791 } 2792 #endif 2793 #elif defined(TARGET_MIPS) || defined(TARGET_MIPS64) 2794 2795 # if defined(TARGET_ABI_MIPSO32) 2796 struct target_sigcontext { 2797 uint32_t sc_regmask; /* Unused */ 2798 uint32_t sc_status; 2799 uint64_t sc_pc; 2800 uint64_t sc_regs[32]; 2801 uint64_t sc_fpregs[32]; 2802 uint32_t sc_ownedfp; /* Unused */ 2803 uint32_t sc_fpc_csr; 2804 uint32_t sc_fpc_eir; /* Unused */ 2805 uint32_t sc_used_math; 2806 uint32_t sc_dsp; /* dsp status, was sc_ssflags */ 2807 uint32_t pad0; 2808 uint64_t sc_mdhi; 2809 uint64_t sc_mdlo; 2810 target_ulong sc_hi1; /* Was sc_cause */ 2811 target_ulong sc_lo1; /* Was sc_badvaddr */ 2812 target_ulong sc_hi2; /* Was sc_sigset[4] */ 2813 target_ulong sc_lo2; 2814 target_ulong sc_hi3; 2815 target_ulong sc_lo3; 2816 }; 2817 # else /* N32 || N64 */ 2818 struct target_sigcontext { 2819 uint64_t sc_regs[32]; 2820 uint64_t sc_fpregs[32]; 2821 uint64_t sc_mdhi; 2822 uint64_t sc_hi1; 2823 uint64_t sc_hi2; 2824 uint64_t sc_hi3; 2825 uint64_t sc_mdlo; 2826 uint64_t sc_lo1; 2827 uint64_t sc_lo2; 2828 uint64_t sc_lo3; 2829 uint64_t sc_pc; 2830 uint32_t sc_fpc_csr; 2831 uint32_t sc_used_math; 2832 uint32_t sc_dsp; 2833 uint32_t sc_reserved; 2834 }; 2835 # endif /* O32 */ 2836 2837 struct sigframe { 2838 uint32_t sf_ass[4]; /* argument save space for o32 */ 2839 uint32_t sf_code[2]; /* signal trampoline */ 2840 struct target_sigcontext sf_sc; 2841 target_sigset_t sf_mask; 2842 }; 2843 2844 struct target_ucontext { 2845 target_ulong tuc_flags; 2846 target_ulong tuc_link; 2847 target_stack_t tuc_stack; 2848 target_ulong pad0; 2849 struct target_sigcontext tuc_mcontext; 2850 target_sigset_t tuc_sigmask; 2851 }; 2852 2853 struct target_rt_sigframe { 2854 uint32_t rs_ass[4]; /* argument save space for o32 */ 2855 uint32_t rs_code[2]; /* signal trampoline */ 2856 struct target_siginfo rs_info; 2857 struct target_ucontext rs_uc; 2858 }; 2859 2860 /* Install trampoline to jump back from signal handler */ 2861 static inline int install_sigtramp(unsigned int *tramp, unsigned int syscall) 2862 { 2863 int err = 0; 2864 2865 /* 2866 * Set up the return code ... 2867 * 2868 * li v0, __NR__foo_sigreturn 2869 * syscall 2870 */ 2871 2872 __put_user(0x24020000 + syscall, tramp + 0); 2873 __put_user(0x0000000c , tramp + 1); 2874 return err; 2875 } 2876 2877 static inline void setup_sigcontext(CPUMIPSState *regs, 2878 struct target_sigcontext *sc) 2879 { 2880 int i; 2881 2882 __put_user(exception_resume_pc(regs), &sc->sc_pc); 2883 regs->hflags &= ~MIPS_HFLAG_BMASK; 2884 2885 __put_user(0, &sc->sc_regs[0]); 2886 for (i = 1; i < 32; ++i) { 2887 __put_user(regs->active_tc.gpr[i], &sc->sc_regs[i]); 2888 } 2889 2890 __put_user(regs->active_tc.HI[0], &sc->sc_mdhi); 2891 __put_user(regs->active_tc.LO[0], &sc->sc_mdlo); 2892 2893 /* Rather than checking for dsp existence, always copy. The storage 2894 would just be garbage otherwise. */ 2895 __put_user(regs->active_tc.HI[1], &sc->sc_hi1); 2896 __put_user(regs->active_tc.HI[2], &sc->sc_hi2); 2897 __put_user(regs->active_tc.HI[3], &sc->sc_hi3); 2898 __put_user(regs->active_tc.LO[1], &sc->sc_lo1); 2899 __put_user(regs->active_tc.LO[2], &sc->sc_lo2); 2900 __put_user(regs->active_tc.LO[3], &sc->sc_lo3); 2901 { 2902 uint32_t dsp = cpu_rddsp(0x3ff, regs); 2903 __put_user(dsp, &sc->sc_dsp); 2904 } 2905 2906 __put_user(1, &sc->sc_used_math); 2907 2908 for (i = 0; i < 32; ++i) { 2909 __put_user(regs->active_fpu.fpr[i].d, &sc->sc_fpregs[i]); 2910 } 2911 } 2912 2913 static inline void 2914 restore_sigcontext(CPUMIPSState *regs, struct target_sigcontext *sc) 2915 { 2916 int i; 2917 2918 __get_user(regs->CP0_EPC, &sc->sc_pc); 2919 2920 __get_user(regs->active_tc.HI[0], &sc->sc_mdhi); 2921 __get_user(regs->active_tc.LO[0], &sc->sc_mdlo); 2922 2923 for (i = 1; i < 32; ++i) { 2924 __get_user(regs->active_tc.gpr[i], &sc->sc_regs[i]); 2925 } 2926 2927 __get_user(regs->active_tc.HI[1], &sc->sc_hi1); 2928 __get_user(regs->active_tc.HI[2], &sc->sc_hi2); 2929 __get_user(regs->active_tc.HI[3], &sc->sc_hi3); 2930 __get_user(regs->active_tc.LO[1], &sc->sc_lo1); 2931 __get_user(regs->active_tc.LO[2], &sc->sc_lo2); 2932 __get_user(regs->active_tc.LO[3], &sc->sc_lo3); 2933 { 2934 uint32_t dsp; 2935 __get_user(dsp, &sc->sc_dsp); 2936 cpu_wrdsp(dsp, 0x3ff, regs); 2937 } 2938 2939 for (i = 0; i < 32; ++i) { 2940 __get_user(regs->active_fpu.fpr[i].d, &sc->sc_fpregs[i]); 2941 } 2942 } 2943 2944 /* 2945 * Determine which stack to use.. 2946 */ 2947 static inline abi_ulong 2948 get_sigframe(struct target_sigaction *ka, CPUMIPSState *regs, size_t frame_size) 2949 { 2950 unsigned long sp; 2951 2952 /* Default to using normal stack */ 2953 sp = regs->active_tc.gpr[29]; 2954 2955 /* 2956 * FPU emulator may have its own trampoline active just 2957 * above the user stack, 16-bytes before the next lowest 2958 * 16 byte boundary. Try to avoid trashing it. 2959 */ 2960 sp -= 32; 2961 2962 /* This is the X/Open sanctioned signal stack switching. */ 2963 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) { 2964 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 2965 } 2966 2967 return (sp - frame_size) & ~7; 2968 } 2969 2970 static void mips_set_hflags_isa_mode_from_pc(CPUMIPSState *env) 2971 { 2972 if (env->insn_flags & (ASE_MIPS16 | ASE_MICROMIPS)) { 2973 env->hflags &= ~MIPS_HFLAG_M16; 2974 env->hflags |= (env->active_tc.PC & 1) << MIPS_HFLAG_M16_SHIFT; 2975 env->active_tc.PC &= ~(target_ulong) 1; 2976 } 2977 } 2978 2979 # if defined(TARGET_ABI_MIPSO32) 2980 /* compare linux/arch/mips/kernel/signal.c:setup_frame() */ 2981 static void setup_frame(int sig, struct target_sigaction * ka, 2982 target_sigset_t *set, CPUMIPSState *regs) 2983 { 2984 struct sigframe *frame; 2985 abi_ulong frame_addr; 2986 int i; 2987 2988 frame_addr = get_sigframe(ka, regs, sizeof(*frame)); 2989 trace_user_setup_frame(regs, frame_addr); 2990 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 2991 goto give_sigsegv; 2992 } 2993 2994 install_sigtramp(frame->sf_code, TARGET_NR_sigreturn); 2995 2996 setup_sigcontext(regs, &frame->sf_sc); 2997 2998 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 2999 __put_user(set->sig[i], &frame->sf_mask.sig[i]); 3000 } 3001 3002 /* 3003 * Arguments to signal handler: 3004 * 3005 * a0 = signal number 3006 * a1 = 0 (should be cause) 3007 * a2 = pointer to struct sigcontext 3008 * 3009 * $25 and PC point to the signal handler, $29 points to the 3010 * struct sigframe. 3011 */ 3012 regs->active_tc.gpr[ 4] = sig; 3013 regs->active_tc.gpr[ 5] = 0; 3014 regs->active_tc.gpr[ 6] = frame_addr + offsetof(struct sigframe, sf_sc); 3015 regs->active_tc.gpr[29] = frame_addr; 3016 regs->active_tc.gpr[31] = frame_addr + offsetof(struct sigframe, sf_code); 3017 /* The original kernel code sets CP0_EPC to the handler 3018 * since it returns to userland using eret 3019 * we cannot do this here, and we must set PC directly */ 3020 regs->active_tc.PC = regs->active_tc.gpr[25] = ka->_sa_handler; 3021 mips_set_hflags_isa_mode_from_pc(regs); 3022 unlock_user_struct(frame, frame_addr, 1); 3023 return; 3024 3025 give_sigsegv: 3026 force_sig(TARGET_SIGSEGV/*, current*/); 3027 } 3028 3029 long do_sigreturn(CPUMIPSState *regs) 3030 { 3031 struct sigframe *frame; 3032 abi_ulong frame_addr; 3033 sigset_t blocked; 3034 target_sigset_t target_set; 3035 int i; 3036 3037 frame_addr = regs->active_tc.gpr[29]; 3038 trace_user_do_sigreturn(regs, frame_addr); 3039 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 3040 goto badframe; 3041 3042 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 3043 __get_user(target_set.sig[i], &frame->sf_mask.sig[i]); 3044 } 3045 3046 target_to_host_sigset_internal(&blocked, &target_set); 3047 set_sigmask(&blocked); 3048 3049 restore_sigcontext(regs, &frame->sf_sc); 3050 3051 #if 0 3052 /* 3053 * Don't let your children do this ... 3054 */ 3055 __asm__ __volatile__( 3056 "move\t$29, %0\n\t" 3057 "j\tsyscall_exit" 3058 :/* no outputs */ 3059 :"r" (®s)); 3060 /* Unreached */ 3061 #endif 3062 3063 regs->active_tc.PC = regs->CP0_EPC; 3064 mips_set_hflags_isa_mode_from_pc(regs); 3065 /* I am not sure this is right, but it seems to work 3066 * maybe a problem with nested signals ? */ 3067 regs->CP0_EPC = 0; 3068 return -TARGET_QEMU_ESIGRETURN; 3069 3070 badframe: 3071 force_sig(TARGET_SIGSEGV/*, current*/); 3072 return 0; 3073 } 3074 # endif /* O32 */ 3075 3076 static void setup_rt_frame(int sig, struct target_sigaction *ka, 3077 target_siginfo_t *info, 3078 target_sigset_t *set, CPUMIPSState *env) 3079 { 3080 struct target_rt_sigframe *frame; 3081 abi_ulong frame_addr; 3082 int i; 3083 3084 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 3085 trace_user_setup_rt_frame(env, frame_addr); 3086 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 3087 goto give_sigsegv; 3088 } 3089 3090 install_sigtramp(frame->rs_code, TARGET_NR_rt_sigreturn); 3091 3092 tswap_siginfo(&frame->rs_info, info); 3093 3094 __put_user(0, &frame->rs_uc.tuc_flags); 3095 __put_user(0, &frame->rs_uc.tuc_link); 3096 __put_user(target_sigaltstack_used.ss_sp, &frame->rs_uc.tuc_stack.ss_sp); 3097 __put_user(target_sigaltstack_used.ss_size, &frame->rs_uc.tuc_stack.ss_size); 3098 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), 3099 &frame->rs_uc.tuc_stack.ss_flags); 3100 3101 setup_sigcontext(env, &frame->rs_uc.tuc_mcontext); 3102 3103 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 3104 __put_user(set->sig[i], &frame->rs_uc.tuc_sigmask.sig[i]); 3105 } 3106 3107 /* 3108 * Arguments to signal handler: 3109 * 3110 * a0 = signal number 3111 * a1 = pointer to siginfo_t 3112 * a2 = pointer to struct ucontext 3113 * 3114 * $25 and PC point to the signal handler, $29 points to the 3115 * struct sigframe. 3116 */ 3117 env->active_tc.gpr[ 4] = sig; 3118 env->active_tc.gpr[ 5] = frame_addr 3119 + offsetof(struct target_rt_sigframe, rs_info); 3120 env->active_tc.gpr[ 6] = frame_addr 3121 + offsetof(struct target_rt_sigframe, rs_uc); 3122 env->active_tc.gpr[29] = frame_addr; 3123 env->active_tc.gpr[31] = frame_addr 3124 + offsetof(struct target_rt_sigframe, rs_code); 3125 /* The original kernel code sets CP0_EPC to the handler 3126 * since it returns to userland using eret 3127 * we cannot do this here, and we must set PC directly */ 3128 env->active_tc.PC = env->active_tc.gpr[25] = ka->_sa_handler; 3129 mips_set_hflags_isa_mode_from_pc(env); 3130 unlock_user_struct(frame, frame_addr, 1); 3131 return; 3132 3133 give_sigsegv: 3134 unlock_user_struct(frame, frame_addr, 1); 3135 force_sig(TARGET_SIGSEGV/*, current*/); 3136 } 3137 3138 long do_rt_sigreturn(CPUMIPSState *env) 3139 { 3140 struct target_rt_sigframe *frame; 3141 abi_ulong frame_addr; 3142 sigset_t blocked; 3143 3144 frame_addr = env->active_tc.gpr[29]; 3145 trace_user_do_rt_sigreturn(env, frame_addr); 3146 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) { 3147 goto badframe; 3148 } 3149 3150 target_to_host_sigset(&blocked, &frame->rs_uc.tuc_sigmask); 3151 set_sigmask(&blocked); 3152 3153 restore_sigcontext(env, &frame->rs_uc.tuc_mcontext); 3154 3155 if (do_sigaltstack(frame_addr + 3156 offsetof(struct target_rt_sigframe, rs_uc.tuc_stack), 3157 0, get_sp_from_cpustate(env)) == -EFAULT) 3158 goto badframe; 3159 3160 env->active_tc.PC = env->CP0_EPC; 3161 mips_set_hflags_isa_mode_from_pc(env); 3162 /* I am not sure this is right, but it seems to work 3163 * maybe a problem with nested signals ? */ 3164 env->CP0_EPC = 0; 3165 return -TARGET_QEMU_ESIGRETURN; 3166 3167 badframe: 3168 force_sig(TARGET_SIGSEGV/*, current*/); 3169 return 0; 3170 } 3171 3172 #elif defined(TARGET_SH4) 3173 3174 /* 3175 * code and data structures from linux kernel: 3176 * include/asm-sh/sigcontext.h 3177 * arch/sh/kernel/signal.c 3178 */ 3179 3180 struct target_sigcontext { 3181 target_ulong oldmask; 3182 3183 /* CPU registers */ 3184 target_ulong sc_gregs[16]; 3185 target_ulong sc_pc; 3186 target_ulong sc_pr; 3187 target_ulong sc_sr; 3188 target_ulong sc_gbr; 3189 target_ulong sc_mach; 3190 target_ulong sc_macl; 3191 3192 /* FPU registers */ 3193 target_ulong sc_fpregs[16]; 3194 target_ulong sc_xfpregs[16]; 3195 unsigned int sc_fpscr; 3196 unsigned int sc_fpul; 3197 unsigned int sc_ownedfp; 3198 }; 3199 3200 struct target_sigframe 3201 { 3202 struct target_sigcontext sc; 3203 target_ulong extramask[TARGET_NSIG_WORDS-1]; 3204 uint16_t retcode[3]; 3205 }; 3206 3207 3208 struct target_ucontext { 3209 target_ulong tuc_flags; 3210 struct target_ucontext *tuc_link; 3211 target_stack_t tuc_stack; 3212 struct target_sigcontext tuc_mcontext; 3213 target_sigset_t tuc_sigmask; /* mask last for extensibility */ 3214 }; 3215 3216 struct target_rt_sigframe 3217 { 3218 struct target_siginfo info; 3219 struct target_ucontext uc; 3220 uint16_t retcode[3]; 3221 }; 3222 3223 3224 #define MOVW(n) (0x9300|((n)-2)) /* Move mem word at PC+n to R3 */ 3225 #define TRAP_NOARG 0xc310 /* Syscall w/no args (NR in R3) SH3/4 */ 3226 3227 static abi_ulong get_sigframe(struct target_sigaction *ka, 3228 unsigned long sp, size_t frame_size) 3229 { 3230 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags(sp) == 0)) { 3231 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 3232 } 3233 3234 return (sp - frame_size) & -8ul; 3235 } 3236 3237 static void setup_sigcontext(struct target_sigcontext *sc, 3238 CPUSH4State *regs, unsigned long mask) 3239 { 3240 int i; 3241 3242 #define COPY(x) __put_user(regs->x, &sc->sc_##x) 3243 COPY(gregs[0]); COPY(gregs[1]); 3244 COPY(gregs[2]); COPY(gregs[3]); 3245 COPY(gregs[4]); COPY(gregs[5]); 3246 COPY(gregs[6]); COPY(gregs[7]); 3247 COPY(gregs[8]); COPY(gregs[9]); 3248 COPY(gregs[10]); COPY(gregs[11]); 3249 COPY(gregs[12]); COPY(gregs[13]); 3250 COPY(gregs[14]); COPY(gregs[15]); 3251 COPY(gbr); COPY(mach); 3252 COPY(macl); COPY(pr); 3253 COPY(sr); COPY(pc); 3254 #undef COPY 3255 3256 for (i=0; i<16; i++) { 3257 __put_user(regs->fregs[i], &sc->sc_fpregs[i]); 3258 } 3259 __put_user(regs->fpscr, &sc->sc_fpscr); 3260 __put_user(regs->fpul, &sc->sc_fpul); 3261 3262 /* non-iBCS2 extensions.. */ 3263 __put_user(mask, &sc->oldmask); 3264 } 3265 3266 static void restore_sigcontext(CPUSH4State *regs, struct target_sigcontext *sc) 3267 { 3268 int i; 3269 3270 #define COPY(x) __get_user(regs->x, &sc->sc_##x) 3271 COPY(gregs[0]); COPY(gregs[1]); 3272 COPY(gregs[2]); COPY(gregs[3]); 3273 COPY(gregs[4]); COPY(gregs[5]); 3274 COPY(gregs[6]); COPY(gregs[7]); 3275 COPY(gregs[8]); COPY(gregs[9]); 3276 COPY(gregs[10]); COPY(gregs[11]); 3277 COPY(gregs[12]); COPY(gregs[13]); 3278 COPY(gregs[14]); COPY(gregs[15]); 3279 COPY(gbr); COPY(mach); 3280 COPY(macl); COPY(pr); 3281 COPY(sr); COPY(pc); 3282 #undef COPY 3283 3284 for (i=0; i<16; i++) { 3285 __get_user(regs->fregs[i], &sc->sc_fpregs[i]); 3286 } 3287 __get_user(regs->fpscr, &sc->sc_fpscr); 3288 __get_user(regs->fpul, &sc->sc_fpul); 3289 3290 regs->tra = -1; /* disable syscall checks */ 3291 } 3292 3293 static void setup_frame(int sig, struct target_sigaction *ka, 3294 target_sigset_t *set, CPUSH4State *regs) 3295 { 3296 struct target_sigframe *frame; 3297 abi_ulong frame_addr; 3298 int i; 3299 3300 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame)); 3301 trace_user_setup_frame(regs, frame_addr); 3302 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 3303 goto give_sigsegv; 3304 } 3305 3306 setup_sigcontext(&frame->sc, regs, set->sig[0]); 3307 3308 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) { 3309 __put_user(set->sig[i + 1], &frame->extramask[i]); 3310 } 3311 3312 /* Set up to return from userspace. If provided, use a stub 3313 already in userspace. */ 3314 if (ka->sa_flags & TARGET_SA_RESTORER) { 3315 regs->pr = (unsigned long) ka->sa_restorer; 3316 } else { 3317 /* Generate return code (system call to sigreturn) */ 3318 abi_ulong retcode_addr = frame_addr + 3319 offsetof(struct target_sigframe, retcode); 3320 __put_user(MOVW(2), &frame->retcode[0]); 3321 __put_user(TRAP_NOARG, &frame->retcode[1]); 3322 __put_user((TARGET_NR_sigreturn), &frame->retcode[2]); 3323 regs->pr = (unsigned long) retcode_addr; 3324 } 3325 3326 /* Set up registers for signal handler */ 3327 regs->gregs[15] = frame_addr; 3328 regs->gregs[4] = sig; /* Arg for signal handler */ 3329 regs->gregs[5] = 0; 3330 regs->gregs[6] = frame_addr += offsetof(typeof(*frame), sc); 3331 regs->pc = (unsigned long) ka->_sa_handler; 3332 3333 unlock_user_struct(frame, frame_addr, 1); 3334 return; 3335 3336 give_sigsegv: 3337 unlock_user_struct(frame, frame_addr, 1); 3338 force_sig(TARGET_SIGSEGV); 3339 } 3340 3341 static void setup_rt_frame(int sig, struct target_sigaction *ka, 3342 target_siginfo_t *info, 3343 target_sigset_t *set, CPUSH4State *regs) 3344 { 3345 struct target_rt_sigframe *frame; 3346 abi_ulong frame_addr; 3347 int i; 3348 3349 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame)); 3350 trace_user_setup_rt_frame(regs, frame_addr); 3351 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 3352 goto give_sigsegv; 3353 } 3354 3355 tswap_siginfo(&frame->info, info); 3356 3357 /* Create the ucontext. */ 3358 __put_user(0, &frame->uc.tuc_flags); 3359 __put_user(0, (unsigned long *)&frame->uc.tuc_link); 3360 __put_user((unsigned long)target_sigaltstack_used.ss_sp, 3361 &frame->uc.tuc_stack.ss_sp); 3362 __put_user(sas_ss_flags(regs->gregs[15]), 3363 &frame->uc.tuc_stack.ss_flags); 3364 __put_user(target_sigaltstack_used.ss_size, 3365 &frame->uc.tuc_stack.ss_size); 3366 setup_sigcontext(&frame->uc.tuc_mcontext, 3367 regs, set->sig[0]); 3368 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 3369 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]); 3370 } 3371 3372 /* Set up to return from userspace. If provided, use a stub 3373 already in userspace. */ 3374 if (ka->sa_flags & TARGET_SA_RESTORER) { 3375 regs->pr = (unsigned long) ka->sa_restorer; 3376 } else { 3377 /* Generate return code (system call to sigreturn) */ 3378 abi_ulong retcode_addr = frame_addr + 3379 offsetof(struct target_rt_sigframe, retcode); 3380 __put_user(MOVW(2), &frame->retcode[0]); 3381 __put_user(TRAP_NOARG, &frame->retcode[1]); 3382 __put_user((TARGET_NR_rt_sigreturn), &frame->retcode[2]); 3383 regs->pr = (unsigned long) retcode_addr; 3384 } 3385 3386 /* Set up registers for signal handler */ 3387 regs->gregs[15] = frame_addr; 3388 regs->gregs[4] = sig; /* Arg for signal handler */ 3389 regs->gregs[5] = frame_addr + offsetof(typeof(*frame), info); 3390 regs->gregs[6] = frame_addr + offsetof(typeof(*frame), uc); 3391 regs->pc = (unsigned long) ka->_sa_handler; 3392 3393 unlock_user_struct(frame, frame_addr, 1); 3394 return; 3395 3396 give_sigsegv: 3397 unlock_user_struct(frame, frame_addr, 1); 3398 force_sig(TARGET_SIGSEGV); 3399 } 3400 3401 long do_sigreturn(CPUSH4State *regs) 3402 { 3403 struct target_sigframe *frame; 3404 abi_ulong frame_addr; 3405 sigset_t blocked; 3406 target_sigset_t target_set; 3407 int i; 3408 int err = 0; 3409 3410 frame_addr = regs->gregs[15]; 3411 trace_user_do_sigreturn(regs, frame_addr); 3412 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) { 3413 goto badframe; 3414 } 3415 3416 __get_user(target_set.sig[0], &frame->sc.oldmask); 3417 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 3418 __get_user(target_set.sig[i], &frame->extramask[i - 1]); 3419 } 3420 3421 if (err) 3422 goto badframe; 3423 3424 target_to_host_sigset_internal(&blocked, &target_set); 3425 set_sigmask(&blocked); 3426 3427 restore_sigcontext(regs, &frame->sc); 3428 3429 unlock_user_struct(frame, frame_addr, 0); 3430 return -TARGET_QEMU_ESIGRETURN; 3431 3432 badframe: 3433 unlock_user_struct(frame, frame_addr, 0); 3434 force_sig(TARGET_SIGSEGV); 3435 return 0; 3436 } 3437 3438 long do_rt_sigreturn(CPUSH4State *regs) 3439 { 3440 struct target_rt_sigframe *frame; 3441 abi_ulong frame_addr; 3442 sigset_t blocked; 3443 3444 frame_addr = regs->gregs[15]; 3445 trace_user_do_rt_sigreturn(regs, frame_addr); 3446 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) { 3447 goto badframe; 3448 } 3449 3450 target_to_host_sigset(&blocked, &frame->uc.tuc_sigmask); 3451 set_sigmask(&blocked); 3452 3453 restore_sigcontext(regs, &frame->uc.tuc_mcontext); 3454 3455 if (do_sigaltstack(frame_addr + 3456 offsetof(struct target_rt_sigframe, uc.tuc_stack), 3457 0, get_sp_from_cpustate(regs)) == -EFAULT) { 3458 goto badframe; 3459 } 3460 3461 unlock_user_struct(frame, frame_addr, 0); 3462 return -TARGET_QEMU_ESIGRETURN; 3463 3464 badframe: 3465 unlock_user_struct(frame, frame_addr, 0); 3466 force_sig(TARGET_SIGSEGV); 3467 return 0; 3468 } 3469 #elif defined(TARGET_MICROBLAZE) 3470 3471 struct target_sigcontext { 3472 struct target_pt_regs regs; /* needs to be first */ 3473 uint32_t oldmask; 3474 }; 3475 3476 struct target_stack_t { 3477 abi_ulong ss_sp; 3478 int ss_flags; 3479 unsigned int ss_size; 3480 }; 3481 3482 struct target_ucontext { 3483 abi_ulong tuc_flags; 3484 abi_ulong tuc_link; 3485 struct target_stack_t tuc_stack; 3486 struct target_sigcontext tuc_mcontext; 3487 uint32_t tuc_extramask[TARGET_NSIG_WORDS - 1]; 3488 }; 3489 3490 /* Signal frames. */ 3491 struct target_signal_frame { 3492 struct target_ucontext uc; 3493 uint32_t extramask[TARGET_NSIG_WORDS - 1]; 3494 uint32_t tramp[2]; 3495 }; 3496 3497 struct rt_signal_frame { 3498 siginfo_t info; 3499 struct ucontext uc; 3500 uint32_t tramp[2]; 3501 }; 3502 3503 static void setup_sigcontext(struct target_sigcontext *sc, CPUMBState *env) 3504 { 3505 __put_user(env->regs[0], &sc->regs.r0); 3506 __put_user(env->regs[1], &sc->regs.r1); 3507 __put_user(env->regs[2], &sc->regs.r2); 3508 __put_user(env->regs[3], &sc->regs.r3); 3509 __put_user(env->regs[4], &sc->regs.r4); 3510 __put_user(env->regs[5], &sc->regs.r5); 3511 __put_user(env->regs[6], &sc->regs.r6); 3512 __put_user(env->regs[7], &sc->regs.r7); 3513 __put_user(env->regs[8], &sc->regs.r8); 3514 __put_user(env->regs[9], &sc->regs.r9); 3515 __put_user(env->regs[10], &sc->regs.r10); 3516 __put_user(env->regs[11], &sc->regs.r11); 3517 __put_user(env->regs[12], &sc->regs.r12); 3518 __put_user(env->regs[13], &sc->regs.r13); 3519 __put_user(env->regs[14], &sc->regs.r14); 3520 __put_user(env->regs[15], &sc->regs.r15); 3521 __put_user(env->regs[16], &sc->regs.r16); 3522 __put_user(env->regs[17], &sc->regs.r17); 3523 __put_user(env->regs[18], &sc->regs.r18); 3524 __put_user(env->regs[19], &sc->regs.r19); 3525 __put_user(env->regs[20], &sc->regs.r20); 3526 __put_user(env->regs[21], &sc->regs.r21); 3527 __put_user(env->regs[22], &sc->regs.r22); 3528 __put_user(env->regs[23], &sc->regs.r23); 3529 __put_user(env->regs[24], &sc->regs.r24); 3530 __put_user(env->regs[25], &sc->regs.r25); 3531 __put_user(env->regs[26], &sc->regs.r26); 3532 __put_user(env->regs[27], &sc->regs.r27); 3533 __put_user(env->regs[28], &sc->regs.r28); 3534 __put_user(env->regs[29], &sc->regs.r29); 3535 __put_user(env->regs[30], &sc->regs.r30); 3536 __put_user(env->regs[31], &sc->regs.r31); 3537 __put_user(env->sregs[SR_PC], &sc->regs.pc); 3538 } 3539 3540 static void restore_sigcontext(struct target_sigcontext *sc, CPUMBState *env) 3541 { 3542 __get_user(env->regs[0], &sc->regs.r0); 3543 __get_user(env->regs[1], &sc->regs.r1); 3544 __get_user(env->regs[2], &sc->regs.r2); 3545 __get_user(env->regs[3], &sc->regs.r3); 3546 __get_user(env->regs[4], &sc->regs.r4); 3547 __get_user(env->regs[5], &sc->regs.r5); 3548 __get_user(env->regs[6], &sc->regs.r6); 3549 __get_user(env->regs[7], &sc->regs.r7); 3550 __get_user(env->regs[8], &sc->regs.r8); 3551 __get_user(env->regs[9], &sc->regs.r9); 3552 __get_user(env->regs[10], &sc->regs.r10); 3553 __get_user(env->regs[11], &sc->regs.r11); 3554 __get_user(env->regs[12], &sc->regs.r12); 3555 __get_user(env->regs[13], &sc->regs.r13); 3556 __get_user(env->regs[14], &sc->regs.r14); 3557 __get_user(env->regs[15], &sc->regs.r15); 3558 __get_user(env->regs[16], &sc->regs.r16); 3559 __get_user(env->regs[17], &sc->regs.r17); 3560 __get_user(env->regs[18], &sc->regs.r18); 3561 __get_user(env->regs[19], &sc->regs.r19); 3562 __get_user(env->regs[20], &sc->regs.r20); 3563 __get_user(env->regs[21], &sc->regs.r21); 3564 __get_user(env->regs[22], &sc->regs.r22); 3565 __get_user(env->regs[23], &sc->regs.r23); 3566 __get_user(env->regs[24], &sc->regs.r24); 3567 __get_user(env->regs[25], &sc->regs.r25); 3568 __get_user(env->regs[26], &sc->regs.r26); 3569 __get_user(env->regs[27], &sc->regs.r27); 3570 __get_user(env->regs[28], &sc->regs.r28); 3571 __get_user(env->regs[29], &sc->regs.r29); 3572 __get_user(env->regs[30], &sc->regs.r30); 3573 __get_user(env->regs[31], &sc->regs.r31); 3574 __get_user(env->sregs[SR_PC], &sc->regs.pc); 3575 } 3576 3577 static abi_ulong get_sigframe(struct target_sigaction *ka, 3578 CPUMBState *env, int frame_size) 3579 { 3580 abi_ulong sp = env->regs[1]; 3581 3582 if ((ka->sa_flags & TARGET_SA_ONSTACK) != 0 && !on_sig_stack(sp)) { 3583 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 3584 } 3585 3586 return ((sp - frame_size) & -8UL); 3587 } 3588 3589 static void setup_frame(int sig, struct target_sigaction *ka, 3590 target_sigset_t *set, CPUMBState *env) 3591 { 3592 struct target_signal_frame *frame; 3593 abi_ulong frame_addr; 3594 int i; 3595 3596 frame_addr = get_sigframe(ka, env, sizeof *frame); 3597 trace_user_setup_frame(env, frame_addr); 3598 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 3599 goto badframe; 3600 3601 /* Save the mask. */ 3602 __put_user(set->sig[0], &frame->uc.tuc_mcontext.oldmask); 3603 3604 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 3605 __put_user(set->sig[i], &frame->extramask[i - 1]); 3606 } 3607 3608 setup_sigcontext(&frame->uc.tuc_mcontext, env); 3609 3610 /* Set up to return from userspace. If provided, use a stub 3611 already in userspace. */ 3612 /* minus 8 is offset to cater for "rtsd r15,8" offset */ 3613 if (ka->sa_flags & TARGET_SA_RESTORER) { 3614 env->regs[15] = ((unsigned long)ka->sa_restorer)-8; 3615 } else { 3616 uint32_t t; 3617 /* Note, these encodings are _big endian_! */ 3618 /* addi r12, r0, __NR_sigreturn */ 3619 t = 0x31800000UL | TARGET_NR_sigreturn; 3620 __put_user(t, frame->tramp + 0); 3621 /* brki r14, 0x8 */ 3622 t = 0xb9cc0008UL; 3623 __put_user(t, frame->tramp + 1); 3624 3625 /* Return from sighandler will jump to the tramp. 3626 Negative 8 offset because return is rtsd r15, 8 */ 3627 env->regs[15] = frame_addr + offsetof(struct target_signal_frame, tramp) 3628 - 8; 3629 } 3630 3631 /* Set up registers for signal handler */ 3632 env->regs[1] = frame_addr; 3633 /* Signal handler args: */ 3634 env->regs[5] = sig; /* Arg 0: signum */ 3635 env->regs[6] = 0; 3636 /* arg 1: sigcontext */ 3637 env->regs[7] = frame_addr += offsetof(typeof(*frame), uc); 3638 3639 /* Offset of 4 to handle microblaze rtid r14, 0 */ 3640 env->sregs[SR_PC] = (unsigned long)ka->_sa_handler; 3641 3642 unlock_user_struct(frame, frame_addr, 1); 3643 return; 3644 badframe: 3645 force_sig(TARGET_SIGSEGV); 3646 } 3647 3648 static void setup_rt_frame(int sig, struct target_sigaction *ka, 3649 target_siginfo_t *info, 3650 target_sigset_t *set, CPUMBState *env) 3651 { 3652 fprintf(stderr, "Microblaze setup_rt_frame: not implemented\n"); 3653 } 3654 3655 long do_sigreturn(CPUMBState *env) 3656 { 3657 struct target_signal_frame *frame; 3658 abi_ulong frame_addr; 3659 target_sigset_t target_set; 3660 sigset_t set; 3661 int i; 3662 3663 frame_addr = env->regs[R_SP]; 3664 trace_user_do_sigreturn(env, frame_addr); 3665 /* Make sure the guest isn't playing games. */ 3666 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1)) 3667 goto badframe; 3668 3669 /* Restore blocked signals */ 3670 __get_user(target_set.sig[0], &frame->uc.tuc_mcontext.oldmask); 3671 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 3672 __get_user(target_set.sig[i], &frame->extramask[i - 1]); 3673 } 3674 target_to_host_sigset_internal(&set, &target_set); 3675 set_sigmask(&set); 3676 3677 restore_sigcontext(&frame->uc.tuc_mcontext, env); 3678 /* We got here through a sigreturn syscall, our path back is via an 3679 rtb insn so setup r14 for that. */ 3680 env->regs[14] = env->sregs[SR_PC]; 3681 3682 unlock_user_struct(frame, frame_addr, 0); 3683 return -TARGET_QEMU_ESIGRETURN; 3684 badframe: 3685 force_sig(TARGET_SIGSEGV); 3686 } 3687 3688 long do_rt_sigreturn(CPUMBState *env) 3689 { 3690 trace_user_do_rt_sigreturn(env, 0); 3691 fprintf(stderr, "Microblaze do_rt_sigreturn: not implemented\n"); 3692 return -TARGET_ENOSYS; 3693 } 3694 3695 #elif defined(TARGET_CRIS) 3696 3697 struct target_sigcontext { 3698 struct target_pt_regs regs; /* needs to be first */ 3699 uint32_t oldmask; 3700 uint32_t usp; /* usp before stacking this gunk on it */ 3701 }; 3702 3703 /* Signal frames. */ 3704 struct target_signal_frame { 3705 struct target_sigcontext sc; 3706 uint32_t extramask[TARGET_NSIG_WORDS - 1]; 3707 uint16_t retcode[4]; /* Trampoline code. */ 3708 }; 3709 3710 struct rt_signal_frame { 3711 siginfo_t *pinfo; 3712 void *puc; 3713 siginfo_t info; 3714 struct ucontext uc; 3715 uint16_t retcode[4]; /* Trampoline code. */ 3716 }; 3717 3718 static void setup_sigcontext(struct target_sigcontext *sc, CPUCRISState *env) 3719 { 3720 __put_user(env->regs[0], &sc->regs.r0); 3721 __put_user(env->regs[1], &sc->regs.r1); 3722 __put_user(env->regs[2], &sc->regs.r2); 3723 __put_user(env->regs[3], &sc->regs.r3); 3724 __put_user(env->regs[4], &sc->regs.r4); 3725 __put_user(env->regs[5], &sc->regs.r5); 3726 __put_user(env->regs[6], &sc->regs.r6); 3727 __put_user(env->regs[7], &sc->regs.r7); 3728 __put_user(env->regs[8], &sc->regs.r8); 3729 __put_user(env->regs[9], &sc->regs.r9); 3730 __put_user(env->regs[10], &sc->regs.r10); 3731 __put_user(env->regs[11], &sc->regs.r11); 3732 __put_user(env->regs[12], &sc->regs.r12); 3733 __put_user(env->regs[13], &sc->regs.r13); 3734 __put_user(env->regs[14], &sc->usp); 3735 __put_user(env->regs[15], &sc->regs.acr); 3736 __put_user(env->pregs[PR_MOF], &sc->regs.mof); 3737 __put_user(env->pregs[PR_SRP], &sc->regs.srp); 3738 __put_user(env->pc, &sc->regs.erp); 3739 } 3740 3741 static void restore_sigcontext(struct target_sigcontext *sc, CPUCRISState *env) 3742 { 3743 __get_user(env->regs[0], &sc->regs.r0); 3744 __get_user(env->regs[1], &sc->regs.r1); 3745 __get_user(env->regs[2], &sc->regs.r2); 3746 __get_user(env->regs[3], &sc->regs.r3); 3747 __get_user(env->regs[4], &sc->regs.r4); 3748 __get_user(env->regs[5], &sc->regs.r5); 3749 __get_user(env->regs[6], &sc->regs.r6); 3750 __get_user(env->regs[7], &sc->regs.r7); 3751 __get_user(env->regs[8], &sc->regs.r8); 3752 __get_user(env->regs[9], &sc->regs.r9); 3753 __get_user(env->regs[10], &sc->regs.r10); 3754 __get_user(env->regs[11], &sc->regs.r11); 3755 __get_user(env->regs[12], &sc->regs.r12); 3756 __get_user(env->regs[13], &sc->regs.r13); 3757 __get_user(env->regs[14], &sc->usp); 3758 __get_user(env->regs[15], &sc->regs.acr); 3759 __get_user(env->pregs[PR_MOF], &sc->regs.mof); 3760 __get_user(env->pregs[PR_SRP], &sc->regs.srp); 3761 __get_user(env->pc, &sc->regs.erp); 3762 } 3763 3764 static abi_ulong get_sigframe(CPUCRISState *env, int framesize) 3765 { 3766 abi_ulong sp; 3767 /* Align the stack downwards to 4. */ 3768 sp = (env->regs[R_SP] & ~3); 3769 return sp - framesize; 3770 } 3771 3772 static void setup_frame(int sig, struct target_sigaction *ka, 3773 target_sigset_t *set, CPUCRISState *env) 3774 { 3775 struct target_signal_frame *frame; 3776 abi_ulong frame_addr; 3777 int i; 3778 3779 frame_addr = get_sigframe(env, sizeof *frame); 3780 trace_user_setup_frame(env, frame_addr); 3781 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 3782 goto badframe; 3783 3784 /* 3785 * The CRIS signal return trampoline. A real linux/CRIS kernel doesn't 3786 * use this trampoline anymore but it sets it up for GDB. 3787 * In QEMU, using the trampoline simplifies things a bit so we use it. 3788 * 3789 * This is movu.w __NR_sigreturn, r9; break 13; 3790 */ 3791 __put_user(0x9c5f, frame->retcode+0); 3792 __put_user(TARGET_NR_sigreturn, 3793 frame->retcode + 1); 3794 __put_user(0xe93d, frame->retcode + 2); 3795 3796 /* Save the mask. */ 3797 __put_user(set->sig[0], &frame->sc.oldmask); 3798 3799 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 3800 __put_user(set->sig[i], &frame->extramask[i - 1]); 3801 } 3802 3803 setup_sigcontext(&frame->sc, env); 3804 3805 /* Move the stack and setup the arguments for the handler. */ 3806 env->regs[R_SP] = frame_addr; 3807 env->regs[10] = sig; 3808 env->pc = (unsigned long) ka->_sa_handler; 3809 /* Link SRP so the guest returns through the trampoline. */ 3810 env->pregs[PR_SRP] = frame_addr + offsetof(typeof(*frame), retcode); 3811 3812 unlock_user_struct(frame, frame_addr, 1); 3813 return; 3814 badframe: 3815 force_sig(TARGET_SIGSEGV); 3816 } 3817 3818 static void setup_rt_frame(int sig, struct target_sigaction *ka, 3819 target_siginfo_t *info, 3820 target_sigset_t *set, CPUCRISState *env) 3821 { 3822 fprintf(stderr, "CRIS setup_rt_frame: not implemented\n"); 3823 } 3824 3825 long do_sigreturn(CPUCRISState *env) 3826 { 3827 struct target_signal_frame *frame; 3828 abi_ulong frame_addr; 3829 target_sigset_t target_set; 3830 sigset_t set; 3831 int i; 3832 3833 frame_addr = env->regs[R_SP]; 3834 trace_user_do_sigreturn(env, frame_addr); 3835 /* Make sure the guest isn't playing games. */ 3836 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1)) { 3837 goto badframe; 3838 } 3839 3840 /* Restore blocked signals */ 3841 __get_user(target_set.sig[0], &frame->sc.oldmask); 3842 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 3843 __get_user(target_set.sig[i], &frame->extramask[i - 1]); 3844 } 3845 target_to_host_sigset_internal(&set, &target_set); 3846 set_sigmask(&set); 3847 3848 restore_sigcontext(&frame->sc, env); 3849 unlock_user_struct(frame, frame_addr, 0); 3850 return -TARGET_QEMU_ESIGRETURN; 3851 badframe: 3852 force_sig(TARGET_SIGSEGV); 3853 } 3854 3855 long do_rt_sigreturn(CPUCRISState *env) 3856 { 3857 trace_user_do_rt_sigreturn(env, 0); 3858 fprintf(stderr, "CRIS do_rt_sigreturn: not implemented\n"); 3859 return -TARGET_ENOSYS; 3860 } 3861 3862 #elif defined(TARGET_OPENRISC) 3863 3864 struct target_sigcontext { 3865 struct target_pt_regs regs; 3866 abi_ulong oldmask; 3867 abi_ulong usp; 3868 }; 3869 3870 struct target_ucontext { 3871 abi_ulong tuc_flags; 3872 abi_ulong tuc_link; 3873 target_stack_t tuc_stack; 3874 struct target_sigcontext tuc_mcontext; 3875 target_sigset_t tuc_sigmask; /* mask last for extensibility */ 3876 }; 3877 3878 struct target_rt_sigframe { 3879 abi_ulong pinfo; 3880 uint64_t puc; 3881 struct target_siginfo info; 3882 struct target_sigcontext sc; 3883 struct target_ucontext uc; 3884 unsigned char retcode[16]; /* trampoline code */ 3885 }; 3886 3887 /* This is the asm-generic/ucontext.h version */ 3888 #if 0 3889 static int restore_sigcontext(CPUOpenRISCState *regs, 3890 struct target_sigcontext *sc) 3891 { 3892 unsigned int err = 0; 3893 unsigned long old_usp; 3894 3895 /* Alwys make any pending restarted system call return -EINTR */ 3896 current_thread_info()->restart_block.fn = do_no_restart_syscall; 3897 3898 /* restore the regs from &sc->regs (same as sc, since regs is first) 3899 * (sc is already checked for VERIFY_READ since the sigframe was 3900 * checked in sys_sigreturn previously) 3901 */ 3902 3903 if (copy_from_user(regs, &sc, sizeof(struct target_pt_regs))) { 3904 goto badframe; 3905 } 3906 3907 /* make sure the U-flag is set so user-mode cannot fool us */ 3908 3909 regs->sr &= ~SR_SM; 3910 3911 /* restore the old USP as it was before we stacked the sc etc. 3912 * (we cannot just pop the sigcontext since we aligned the sp and 3913 * stuff after pushing it) 3914 */ 3915 3916 __get_user(old_usp, &sc->usp); 3917 phx_signal("old_usp 0x%lx", old_usp); 3918 3919 __PHX__ REALLY /* ??? */ 3920 wrusp(old_usp); 3921 regs->gpr[1] = old_usp; 3922 3923 /* TODO: the other ports use regs->orig_XX to disable syscall checks 3924 * after this completes, but we don't use that mechanism. maybe we can 3925 * use it now ? 3926 */ 3927 3928 return err; 3929 3930 badframe: 3931 return 1; 3932 } 3933 #endif 3934 3935 /* Set up a signal frame. */ 3936 3937 static void setup_sigcontext(struct target_sigcontext *sc, 3938 CPUOpenRISCState *regs, 3939 unsigned long mask) 3940 { 3941 unsigned long usp = regs->gpr[1]; 3942 3943 /* copy the regs. they are first in sc so we can use sc directly */ 3944 3945 /*copy_to_user(&sc, regs, sizeof(struct target_pt_regs));*/ 3946 3947 /* Set the frametype to CRIS_FRAME_NORMAL for the execution of 3948 the signal handler. The frametype will be restored to its previous 3949 value in restore_sigcontext. */ 3950 /*regs->frametype = CRIS_FRAME_NORMAL;*/ 3951 3952 /* then some other stuff */ 3953 __put_user(mask, &sc->oldmask); 3954 __put_user(usp, &sc->usp); 3955 } 3956 3957 static inline unsigned long align_sigframe(unsigned long sp) 3958 { 3959 unsigned long i; 3960 i = sp & ~3UL; 3961 return i; 3962 } 3963 3964 static inline abi_ulong get_sigframe(struct target_sigaction *ka, 3965 CPUOpenRISCState *regs, 3966 size_t frame_size) 3967 { 3968 unsigned long sp = regs->gpr[1]; 3969 int onsigstack = on_sig_stack(sp); 3970 3971 /* redzone */ 3972 /* This is the X/Open sanctioned signal stack switching. */ 3973 if ((ka->sa_flags & TARGET_SA_ONSTACK) != 0 && !onsigstack) { 3974 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 3975 } 3976 3977 sp = align_sigframe(sp - frame_size); 3978 3979 /* 3980 * If we are on the alternate signal stack and would overflow it, don't. 3981 * Return an always-bogus address instead so we will die with SIGSEGV. 3982 */ 3983 3984 if (onsigstack && !likely(on_sig_stack(sp))) { 3985 return -1L; 3986 } 3987 3988 return sp; 3989 } 3990 3991 static void setup_rt_frame(int sig, struct target_sigaction *ka, 3992 target_siginfo_t *info, 3993 target_sigset_t *set, CPUOpenRISCState *env) 3994 { 3995 int err = 0; 3996 abi_ulong frame_addr; 3997 unsigned long return_ip; 3998 struct target_rt_sigframe *frame; 3999 abi_ulong info_addr, uc_addr; 4000 4001 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 4002 trace_user_setup_rt_frame(env, frame_addr); 4003 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 4004 goto give_sigsegv; 4005 } 4006 4007 info_addr = frame_addr + offsetof(struct target_rt_sigframe, info); 4008 __put_user(info_addr, &frame->pinfo); 4009 uc_addr = frame_addr + offsetof(struct target_rt_sigframe, uc); 4010 __put_user(uc_addr, &frame->puc); 4011 4012 if (ka->sa_flags & SA_SIGINFO) { 4013 tswap_siginfo(&frame->info, info); 4014 } 4015 4016 /*err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext));*/ 4017 __put_user(0, &frame->uc.tuc_flags); 4018 __put_user(0, &frame->uc.tuc_link); 4019 __put_user(target_sigaltstack_used.ss_sp, 4020 &frame->uc.tuc_stack.ss_sp); 4021 __put_user(sas_ss_flags(env->gpr[1]), &frame->uc.tuc_stack.ss_flags); 4022 __put_user(target_sigaltstack_used.ss_size, 4023 &frame->uc.tuc_stack.ss_size); 4024 setup_sigcontext(&frame->sc, env, set->sig[0]); 4025 4026 /*err |= copy_to_user(frame->uc.tuc_sigmask, set, sizeof(*set));*/ 4027 4028 /* trampoline - the desired return ip is the retcode itself */ 4029 return_ip = (unsigned long)&frame->retcode; 4030 /* This is l.ori r11,r0,__NR_sigreturn, l.sys 1 */ 4031 __put_user(0xa960, (short *)(frame->retcode + 0)); 4032 __put_user(TARGET_NR_rt_sigreturn, (short *)(frame->retcode + 2)); 4033 __put_user(0x20000001, (unsigned long *)(frame->retcode + 4)); 4034 __put_user(0x15000000, (unsigned long *)(frame->retcode + 8)); 4035 4036 if (err) { 4037 goto give_sigsegv; 4038 } 4039 4040 /* TODO what is the current->exec_domain stuff and invmap ? */ 4041 4042 /* Set up registers for signal handler */ 4043 env->pc = (unsigned long)ka->_sa_handler; /* what we enter NOW */ 4044 env->gpr[9] = (unsigned long)return_ip; /* what we enter LATER */ 4045 env->gpr[3] = (unsigned long)sig; /* arg 1: signo */ 4046 env->gpr[4] = (unsigned long)&frame->info; /* arg 2: (siginfo_t*) */ 4047 env->gpr[5] = (unsigned long)&frame->uc; /* arg 3: ucontext */ 4048 4049 /* actually move the usp to reflect the stacked frame */ 4050 env->gpr[1] = (unsigned long)frame; 4051 4052 return; 4053 4054 give_sigsegv: 4055 unlock_user_struct(frame, frame_addr, 1); 4056 if (sig == TARGET_SIGSEGV) { 4057 ka->_sa_handler = TARGET_SIG_DFL; 4058 } 4059 force_sig(TARGET_SIGSEGV); 4060 } 4061 4062 long do_sigreturn(CPUOpenRISCState *env) 4063 { 4064 trace_user_do_sigreturn(env, 0); 4065 fprintf(stderr, "do_sigreturn: not implemented\n"); 4066 return -TARGET_ENOSYS; 4067 } 4068 4069 long do_rt_sigreturn(CPUOpenRISCState *env) 4070 { 4071 trace_user_do_rt_sigreturn(env, 0); 4072 fprintf(stderr, "do_rt_sigreturn: not implemented\n"); 4073 return -TARGET_ENOSYS; 4074 } 4075 /* TARGET_OPENRISC */ 4076 4077 #elif defined(TARGET_S390X) 4078 4079 #define __NUM_GPRS 16 4080 #define __NUM_FPRS 16 4081 #define __NUM_ACRS 16 4082 4083 #define S390_SYSCALL_SIZE 2 4084 #define __SIGNAL_FRAMESIZE 160 /* FIXME: 31-bit mode -> 96 */ 4085 4086 #define _SIGCONTEXT_NSIG 64 4087 #define _SIGCONTEXT_NSIG_BPW 64 /* FIXME: 31-bit mode -> 32 */ 4088 #define _SIGCONTEXT_NSIG_WORDS (_SIGCONTEXT_NSIG / _SIGCONTEXT_NSIG_BPW) 4089 #define _SIGMASK_COPY_SIZE (sizeof(unsigned long)*_SIGCONTEXT_NSIG_WORDS) 4090 #define PSW_ADDR_AMODE 0x0000000000000000UL /* 0x80000000UL for 31-bit */ 4091 #define S390_SYSCALL_OPCODE ((uint16_t)0x0a00) 4092 4093 typedef struct { 4094 target_psw_t psw; 4095 target_ulong gprs[__NUM_GPRS]; 4096 unsigned int acrs[__NUM_ACRS]; 4097 } target_s390_regs_common; 4098 4099 typedef struct { 4100 unsigned int fpc; 4101 double fprs[__NUM_FPRS]; 4102 } target_s390_fp_regs; 4103 4104 typedef struct { 4105 target_s390_regs_common regs; 4106 target_s390_fp_regs fpregs; 4107 } target_sigregs; 4108 4109 struct target_sigcontext { 4110 target_ulong oldmask[_SIGCONTEXT_NSIG_WORDS]; 4111 target_sigregs *sregs; 4112 }; 4113 4114 typedef struct { 4115 uint8_t callee_used_stack[__SIGNAL_FRAMESIZE]; 4116 struct target_sigcontext sc; 4117 target_sigregs sregs; 4118 int signo; 4119 uint8_t retcode[S390_SYSCALL_SIZE]; 4120 } sigframe; 4121 4122 struct target_ucontext { 4123 target_ulong tuc_flags; 4124 struct target_ucontext *tuc_link; 4125 target_stack_t tuc_stack; 4126 target_sigregs tuc_mcontext; 4127 target_sigset_t tuc_sigmask; /* mask last for extensibility */ 4128 }; 4129 4130 typedef struct { 4131 uint8_t callee_used_stack[__SIGNAL_FRAMESIZE]; 4132 uint8_t retcode[S390_SYSCALL_SIZE]; 4133 struct target_siginfo info; 4134 struct target_ucontext uc; 4135 } rt_sigframe; 4136 4137 static inline abi_ulong 4138 get_sigframe(struct target_sigaction *ka, CPUS390XState *env, size_t frame_size) 4139 { 4140 abi_ulong sp; 4141 4142 /* Default to using normal stack */ 4143 sp = env->regs[15]; 4144 4145 /* This is the X/Open sanctioned signal stack switching. */ 4146 if (ka->sa_flags & TARGET_SA_ONSTACK) { 4147 if (!sas_ss_flags(sp)) { 4148 sp = target_sigaltstack_used.ss_sp + 4149 target_sigaltstack_used.ss_size; 4150 } 4151 } 4152 4153 /* This is the legacy signal stack switching. */ 4154 else if (/* FIXME !user_mode(regs) */ 0 && 4155 !(ka->sa_flags & TARGET_SA_RESTORER) && 4156 ka->sa_restorer) { 4157 sp = (abi_ulong) ka->sa_restorer; 4158 } 4159 4160 return (sp - frame_size) & -8ul; 4161 } 4162 4163 static void save_sigregs(CPUS390XState *env, target_sigregs *sregs) 4164 { 4165 int i; 4166 //save_access_regs(current->thread.acrs); FIXME 4167 4168 /* Copy a 'clean' PSW mask to the user to avoid leaking 4169 information about whether PER is currently on. */ 4170 __put_user(env->psw.mask, &sregs->regs.psw.mask); 4171 __put_user(env->psw.addr, &sregs->regs.psw.addr); 4172 for (i = 0; i < 16; i++) { 4173 __put_user(env->regs[i], &sregs->regs.gprs[i]); 4174 } 4175 for (i = 0; i < 16; i++) { 4176 __put_user(env->aregs[i], &sregs->regs.acrs[i]); 4177 } 4178 /* 4179 * We have to store the fp registers to current->thread.fp_regs 4180 * to merge them with the emulated registers. 4181 */ 4182 //save_fp_regs(¤t->thread.fp_regs); FIXME 4183 for (i = 0; i < 16; i++) { 4184 __put_user(get_freg(env, i)->ll, &sregs->fpregs.fprs[i]); 4185 } 4186 } 4187 4188 static void setup_frame(int sig, struct target_sigaction *ka, 4189 target_sigset_t *set, CPUS390XState *env) 4190 { 4191 sigframe *frame; 4192 abi_ulong frame_addr; 4193 4194 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 4195 trace_user_setup_frame(env, frame_addr); 4196 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 4197 goto give_sigsegv; 4198 } 4199 4200 __put_user(set->sig[0], &frame->sc.oldmask[0]); 4201 4202 save_sigregs(env, &frame->sregs); 4203 4204 __put_user((abi_ulong)(unsigned long)&frame->sregs, 4205 (abi_ulong *)&frame->sc.sregs); 4206 4207 /* Set up to return from userspace. If provided, use a stub 4208 already in userspace. */ 4209 if (ka->sa_flags & TARGET_SA_RESTORER) { 4210 env->regs[14] = (unsigned long) 4211 ka->sa_restorer | PSW_ADDR_AMODE; 4212 } else { 4213 env->regs[14] = (frame_addr + offsetof(sigframe, retcode)) 4214 | PSW_ADDR_AMODE; 4215 __put_user(S390_SYSCALL_OPCODE | TARGET_NR_sigreturn, 4216 (uint16_t *)(frame->retcode)); 4217 } 4218 4219 /* Set up backchain. */ 4220 __put_user(env->regs[15], (abi_ulong *) frame); 4221 4222 /* Set up registers for signal handler */ 4223 env->regs[15] = frame_addr; 4224 env->psw.addr = (target_ulong) ka->_sa_handler | PSW_ADDR_AMODE; 4225 4226 env->regs[2] = sig; //map_signal(sig); 4227 env->regs[3] = frame_addr += offsetof(typeof(*frame), sc); 4228 4229 /* We forgot to include these in the sigcontext. 4230 To avoid breaking binary compatibility, they are passed as args. */ 4231 env->regs[4] = 0; // FIXME: no clue... current->thread.trap_no; 4232 env->regs[5] = 0; // FIXME: no clue... current->thread.prot_addr; 4233 4234 /* Place signal number on stack to allow backtrace from handler. */ 4235 __put_user(env->regs[2], (int *) &frame->signo); 4236 unlock_user_struct(frame, frame_addr, 1); 4237 return; 4238 4239 give_sigsegv: 4240 force_sig(TARGET_SIGSEGV); 4241 } 4242 4243 static void setup_rt_frame(int sig, struct target_sigaction *ka, 4244 target_siginfo_t *info, 4245 target_sigset_t *set, CPUS390XState *env) 4246 { 4247 int i; 4248 rt_sigframe *frame; 4249 abi_ulong frame_addr; 4250 4251 frame_addr = get_sigframe(ka, env, sizeof *frame); 4252 trace_user_setup_rt_frame(env, frame_addr); 4253 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 4254 goto give_sigsegv; 4255 } 4256 4257 tswap_siginfo(&frame->info, info); 4258 4259 /* Create the ucontext. */ 4260 __put_user(0, &frame->uc.tuc_flags); 4261 __put_user((abi_ulong)0, (abi_ulong *)&frame->uc.tuc_link); 4262 __put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp); 4263 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), 4264 &frame->uc.tuc_stack.ss_flags); 4265 __put_user(target_sigaltstack_used.ss_size, &frame->uc.tuc_stack.ss_size); 4266 save_sigregs(env, &frame->uc.tuc_mcontext); 4267 for (i = 0; i < TARGET_NSIG_WORDS; i++) { 4268 __put_user((abi_ulong)set->sig[i], 4269 (abi_ulong *)&frame->uc.tuc_sigmask.sig[i]); 4270 } 4271 4272 /* Set up to return from userspace. If provided, use a stub 4273 already in userspace. */ 4274 if (ka->sa_flags & TARGET_SA_RESTORER) { 4275 env->regs[14] = (unsigned long) ka->sa_restorer | PSW_ADDR_AMODE; 4276 } else { 4277 env->regs[14] = (unsigned long) frame->retcode | PSW_ADDR_AMODE; 4278 __put_user(S390_SYSCALL_OPCODE | TARGET_NR_rt_sigreturn, 4279 (uint16_t *)(frame->retcode)); 4280 } 4281 4282 /* Set up backchain. */ 4283 __put_user(env->regs[15], (abi_ulong *) frame); 4284 4285 /* Set up registers for signal handler */ 4286 env->regs[15] = frame_addr; 4287 env->psw.addr = (target_ulong) ka->_sa_handler | PSW_ADDR_AMODE; 4288 4289 env->regs[2] = sig; //map_signal(sig); 4290 env->regs[3] = frame_addr + offsetof(typeof(*frame), info); 4291 env->regs[4] = frame_addr + offsetof(typeof(*frame), uc); 4292 return; 4293 4294 give_sigsegv: 4295 force_sig(TARGET_SIGSEGV); 4296 } 4297 4298 static int 4299 restore_sigregs(CPUS390XState *env, target_sigregs *sc) 4300 { 4301 int err = 0; 4302 int i; 4303 4304 for (i = 0; i < 16; i++) { 4305 __get_user(env->regs[i], &sc->regs.gprs[i]); 4306 } 4307 4308 __get_user(env->psw.mask, &sc->regs.psw.mask); 4309 trace_user_s390x_restore_sigregs(env, (unsigned long long)sc->regs.psw.addr, 4310 (unsigned long long)env->psw.addr); 4311 __get_user(env->psw.addr, &sc->regs.psw.addr); 4312 /* FIXME: 31-bit -> | PSW_ADDR_AMODE */ 4313 4314 for (i = 0; i < 16; i++) { 4315 __get_user(env->aregs[i], &sc->regs.acrs[i]); 4316 } 4317 for (i = 0; i < 16; i++) { 4318 __get_user(get_freg(env, i)->ll, &sc->fpregs.fprs[i]); 4319 } 4320 4321 return err; 4322 } 4323 4324 long do_sigreturn(CPUS390XState *env) 4325 { 4326 sigframe *frame; 4327 abi_ulong frame_addr = env->regs[15]; 4328 target_sigset_t target_set; 4329 sigset_t set; 4330 4331 trace_user_do_sigreturn(env, frame_addr); 4332 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) { 4333 goto badframe; 4334 } 4335 __get_user(target_set.sig[0], &frame->sc.oldmask[0]); 4336 4337 target_to_host_sigset_internal(&set, &target_set); 4338 set_sigmask(&set); /* ~_BLOCKABLE? */ 4339 4340 if (restore_sigregs(env, &frame->sregs)) { 4341 goto badframe; 4342 } 4343 4344 unlock_user_struct(frame, frame_addr, 0); 4345 return -TARGET_QEMU_ESIGRETURN; 4346 4347 badframe: 4348 force_sig(TARGET_SIGSEGV); 4349 return 0; 4350 } 4351 4352 long do_rt_sigreturn(CPUS390XState *env) 4353 { 4354 rt_sigframe *frame; 4355 abi_ulong frame_addr = env->regs[15]; 4356 sigset_t set; 4357 4358 trace_user_do_rt_sigreturn(env, frame_addr); 4359 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) { 4360 goto badframe; 4361 } 4362 target_to_host_sigset(&set, &frame->uc.tuc_sigmask); 4363 4364 set_sigmask(&set); /* ~_BLOCKABLE? */ 4365 4366 if (restore_sigregs(env, &frame->uc.tuc_mcontext)) { 4367 goto badframe; 4368 } 4369 4370 if (do_sigaltstack(frame_addr + offsetof(rt_sigframe, uc.tuc_stack), 0, 4371 get_sp_from_cpustate(env)) == -EFAULT) { 4372 goto badframe; 4373 } 4374 unlock_user_struct(frame, frame_addr, 0); 4375 return -TARGET_QEMU_ESIGRETURN; 4376 4377 badframe: 4378 unlock_user_struct(frame, frame_addr, 0); 4379 force_sig(TARGET_SIGSEGV); 4380 return 0; 4381 } 4382 4383 #elif defined(TARGET_PPC) 4384 4385 /* Size of dummy stack frame allocated when calling signal handler. 4386 See arch/powerpc/include/asm/ptrace.h. */ 4387 #if defined(TARGET_PPC64) 4388 #define SIGNAL_FRAMESIZE 128 4389 #else 4390 #define SIGNAL_FRAMESIZE 64 4391 #endif 4392 4393 /* See arch/powerpc/include/asm/ucontext.h. Only used for 32-bit PPC; 4394 on 64-bit PPC, sigcontext and mcontext are one and the same. */ 4395 struct target_mcontext { 4396 target_ulong mc_gregs[48]; 4397 /* Includes fpscr. */ 4398 uint64_t mc_fregs[33]; 4399 target_ulong mc_pad[2]; 4400 /* We need to handle Altivec and SPE at the same time, which no 4401 kernel needs to do. Fortunately, the kernel defines this bit to 4402 be Altivec-register-large all the time, rather than trying to 4403 twiddle it based on the specific platform. */ 4404 union { 4405 /* SPE vector registers. One extra for SPEFSCR. */ 4406 uint32_t spe[33]; 4407 /* Altivec vector registers. The packing of VSCR and VRSAVE 4408 varies depending on whether we're PPC64 or not: PPC64 splits 4409 them apart; PPC32 stuffs them together. */ 4410 #if defined(TARGET_PPC64) 4411 #define QEMU_NVRREG 34 4412 #else 4413 #define QEMU_NVRREG 33 4414 #endif 4415 ppc_avr_t altivec[QEMU_NVRREG]; 4416 #undef QEMU_NVRREG 4417 } mc_vregs __attribute__((__aligned__(16))); 4418 }; 4419 4420 /* See arch/powerpc/include/asm/sigcontext.h. */ 4421 struct target_sigcontext { 4422 target_ulong _unused[4]; 4423 int32_t signal; 4424 #if defined(TARGET_PPC64) 4425 int32_t pad0; 4426 #endif 4427 target_ulong handler; 4428 target_ulong oldmask; 4429 target_ulong regs; /* struct pt_regs __user * */ 4430 #if defined(TARGET_PPC64) 4431 struct target_mcontext mcontext; 4432 #endif 4433 }; 4434 4435 /* Indices for target_mcontext.mc_gregs, below. 4436 See arch/powerpc/include/asm/ptrace.h for details. */ 4437 enum { 4438 TARGET_PT_R0 = 0, 4439 TARGET_PT_R1 = 1, 4440 TARGET_PT_R2 = 2, 4441 TARGET_PT_R3 = 3, 4442 TARGET_PT_R4 = 4, 4443 TARGET_PT_R5 = 5, 4444 TARGET_PT_R6 = 6, 4445 TARGET_PT_R7 = 7, 4446 TARGET_PT_R8 = 8, 4447 TARGET_PT_R9 = 9, 4448 TARGET_PT_R10 = 10, 4449 TARGET_PT_R11 = 11, 4450 TARGET_PT_R12 = 12, 4451 TARGET_PT_R13 = 13, 4452 TARGET_PT_R14 = 14, 4453 TARGET_PT_R15 = 15, 4454 TARGET_PT_R16 = 16, 4455 TARGET_PT_R17 = 17, 4456 TARGET_PT_R18 = 18, 4457 TARGET_PT_R19 = 19, 4458 TARGET_PT_R20 = 20, 4459 TARGET_PT_R21 = 21, 4460 TARGET_PT_R22 = 22, 4461 TARGET_PT_R23 = 23, 4462 TARGET_PT_R24 = 24, 4463 TARGET_PT_R25 = 25, 4464 TARGET_PT_R26 = 26, 4465 TARGET_PT_R27 = 27, 4466 TARGET_PT_R28 = 28, 4467 TARGET_PT_R29 = 29, 4468 TARGET_PT_R30 = 30, 4469 TARGET_PT_R31 = 31, 4470 TARGET_PT_NIP = 32, 4471 TARGET_PT_MSR = 33, 4472 TARGET_PT_ORIG_R3 = 34, 4473 TARGET_PT_CTR = 35, 4474 TARGET_PT_LNK = 36, 4475 TARGET_PT_XER = 37, 4476 TARGET_PT_CCR = 38, 4477 /* Yes, there are two registers with #39. One is 64-bit only. */ 4478 TARGET_PT_MQ = 39, 4479 TARGET_PT_SOFTE = 39, 4480 TARGET_PT_TRAP = 40, 4481 TARGET_PT_DAR = 41, 4482 TARGET_PT_DSISR = 42, 4483 TARGET_PT_RESULT = 43, 4484 TARGET_PT_REGS_COUNT = 44 4485 }; 4486 4487 4488 struct target_ucontext { 4489 target_ulong tuc_flags; 4490 target_ulong tuc_link; /* struct ucontext __user * */ 4491 struct target_sigaltstack tuc_stack; 4492 #if !defined(TARGET_PPC64) 4493 int32_t tuc_pad[7]; 4494 target_ulong tuc_regs; /* struct mcontext __user * 4495 points to uc_mcontext field */ 4496 #endif 4497 target_sigset_t tuc_sigmask; 4498 #if defined(TARGET_PPC64) 4499 target_sigset_t unused[15]; /* Allow for uc_sigmask growth */ 4500 struct target_sigcontext tuc_sigcontext; 4501 #else 4502 int32_t tuc_maskext[30]; 4503 int32_t tuc_pad2[3]; 4504 struct target_mcontext tuc_mcontext; 4505 #endif 4506 }; 4507 4508 /* See arch/powerpc/kernel/signal_32.c. */ 4509 struct target_sigframe { 4510 struct target_sigcontext sctx; 4511 struct target_mcontext mctx; 4512 int32_t abigap[56]; 4513 }; 4514 4515 #if defined(TARGET_PPC64) 4516 4517 #define TARGET_TRAMP_SIZE 6 4518 4519 struct target_rt_sigframe { 4520 /* sys_rt_sigreturn requires the ucontext be the first field */ 4521 struct target_ucontext uc; 4522 target_ulong _unused[2]; 4523 uint32_t trampoline[TARGET_TRAMP_SIZE]; 4524 target_ulong pinfo; /* struct siginfo __user * */ 4525 target_ulong puc; /* void __user * */ 4526 struct target_siginfo info; 4527 /* 64 bit ABI allows for 288 bytes below sp before decrementing it. */ 4528 char abigap[288]; 4529 } __attribute__((aligned(16))); 4530 4531 #else 4532 4533 struct target_rt_sigframe { 4534 struct target_siginfo info; 4535 struct target_ucontext uc; 4536 int32_t abigap[56]; 4537 }; 4538 4539 #endif 4540 4541 #if defined(TARGET_PPC64) 4542 4543 struct target_func_ptr { 4544 target_ulong entry; 4545 target_ulong toc; 4546 }; 4547 4548 #endif 4549 4550 /* We use the mc_pad field for the signal return trampoline. */ 4551 #define tramp mc_pad 4552 4553 /* See arch/powerpc/kernel/signal.c. */ 4554 static target_ulong get_sigframe(struct target_sigaction *ka, 4555 CPUPPCState *env, 4556 int frame_size) 4557 { 4558 target_ulong oldsp, newsp; 4559 4560 oldsp = env->gpr[1]; 4561 4562 if ((ka->sa_flags & TARGET_SA_ONSTACK) && 4563 (sas_ss_flags(oldsp) == 0)) { 4564 oldsp = (target_sigaltstack_used.ss_sp 4565 + target_sigaltstack_used.ss_size); 4566 } 4567 4568 newsp = (oldsp - frame_size) & ~0xFUL; 4569 4570 return newsp; 4571 } 4572 4573 static void save_user_regs(CPUPPCState *env, struct target_mcontext *frame) 4574 { 4575 target_ulong msr = env->msr; 4576 int i; 4577 target_ulong ccr = 0; 4578 4579 /* In general, the kernel attempts to be intelligent about what it 4580 needs to save for Altivec/FP/SPE registers. We don't care that 4581 much, so we just go ahead and save everything. */ 4582 4583 /* Save general registers. */ 4584 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) { 4585 __put_user(env->gpr[i], &frame->mc_gregs[i]); 4586 } 4587 __put_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP]); 4588 __put_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR]); 4589 __put_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK]); 4590 __put_user(env->xer, &frame->mc_gregs[TARGET_PT_XER]); 4591 4592 for (i = 0; i < ARRAY_SIZE(env->crf); i++) { 4593 ccr |= env->crf[i] << (32 - ((i + 1) * 4)); 4594 } 4595 __put_user(ccr, &frame->mc_gregs[TARGET_PT_CCR]); 4596 4597 /* Save Altivec registers if necessary. */ 4598 if (env->insns_flags & PPC_ALTIVEC) { 4599 for (i = 0; i < ARRAY_SIZE(env->avr); i++) { 4600 ppc_avr_t *avr = &env->avr[i]; 4601 ppc_avr_t *vreg = &frame->mc_vregs.altivec[i]; 4602 4603 __put_user(avr->u64[0], &vreg->u64[0]); 4604 __put_user(avr->u64[1], &vreg->u64[1]); 4605 } 4606 /* Set MSR_VR in the saved MSR value to indicate that 4607 frame->mc_vregs contains valid data. */ 4608 msr |= MSR_VR; 4609 __put_user((uint32_t)env->spr[SPR_VRSAVE], 4610 &frame->mc_vregs.altivec[32].u32[3]); 4611 } 4612 4613 /* Save floating point registers. */ 4614 if (env->insns_flags & PPC_FLOAT) { 4615 for (i = 0; i < ARRAY_SIZE(env->fpr); i++) { 4616 __put_user(env->fpr[i], &frame->mc_fregs[i]); 4617 } 4618 __put_user((uint64_t) env->fpscr, &frame->mc_fregs[32]); 4619 } 4620 4621 /* Save SPE registers. The kernel only saves the high half. */ 4622 if (env->insns_flags & PPC_SPE) { 4623 #if defined(TARGET_PPC64) 4624 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) { 4625 __put_user(env->gpr[i] >> 32, &frame->mc_vregs.spe[i]); 4626 } 4627 #else 4628 for (i = 0; i < ARRAY_SIZE(env->gprh); i++) { 4629 __put_user(env->gprh[i], &frame->mc_vregs.spe[i]); 4630 } 4631 #endif 4632 /* Set MSR_SPE in the saved MSR value to indicate that 4633 frame->mc_vregs contains valid data. */ 4634 msr |= MSR_SPE; 4635 __put_user(env->spe_fscr, &frame->mc_vregs.spe[32]); 4636 } 4637 4638 /* Store MSR. */ 4639 __put_user(msr, &frame->mc_gregs[TARGET_PT_MSR]); 4640 } 4641 4642 static void encode_trampoline(int sigret, uint32_t *tramp) 4643 { 4644 /* Set up the sigreturn trampoline: li r0,sigret; sc. */ 4645 if (sigret) { 4646 __put_user(0x38000000 | sigret, &tramp[0]); 4647 __put_user(0x44000002, &tramp[1]); 4648 } 4649 } 4650 4651 static void restore_user_regs(CPUPPCState *env, 4652 struct target_mcontext *frame, int sig) 4653 { 4654 target_ulong save_r2 = 0; 4655 target_ulong msr; 4656 target_ulong ccr; 4657 4658 int i; 4659 4660 if (!sig) { 4661 save_r2 = env->gpr[2]; 4662 } 4663 4664 /* Restore general registers. */ 4665 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) { 4666 __get_user(env->gpr[i], &frame->mc_gregs[i]); 4667 } 4668 __get_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP]); 4669 __get_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR]); 4670 __get_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK]); 4671 __get_user(env->xer, &frame->mc_gregs[TARGET_PT_XER]); 4672 __get_user(ccr, &frame->mc_gregs[TARGET_PT_CCR]); 4673 4674 for (i = 0; i < ARRAY_SIZE(env->crf); i++) { 4675 env->crf[i] = (ccr >> (32 - ((i + 1) * 4))) & 0xf; 4676 } 4677 4678 if (!sig) { 4679 env->gpr[2] = save_r2; 4680 } 4681 /* Restore MSR. */ 4682 __get_user(msr, &frame->mc_gregs[TARGET_PT_MSR]); 4683 4684 /* If doing signal return, restore the previous little-endian mode. */ 4685 if (sig) 4686 env->msr = (env->msr & ~(1ull << MSR_LE)) | (msr & (1ull << MSR_LE)); 4687 4688 /* Restore Altivec registers if necessary. */ 4689 if (env->insns_flags & PPC_ALTIVEC) { 4690 for (i = 0; i < ARRAY_SIZE(env->avr); i++) { 4691 ppc_avr_t *avr = &env->avr[i]; 4692 ppc_avr_t *vreg = &frame->mc_vregs.altivec[i]; 4693 4694 __get_user(avr->u64[0], &vreg->u64[0]); 4695 __get_user(avr->u64[1], &vreg->u64[1]); 4696 } 4697 /* Set MSR_VEC in the saved MSR value to indicate that 4698 frame->mc_vregs contains valid data. */ 4699 __get_user(env->spr[SPR_VRSAVE], 4700 (target_ulong *)(&frame->mc_vregs.altivec[32].u32[3])); 4701 } 4702 4703 /* Restore floating point registers. */ 4704 if (env->insns_flags & PPC_FLOAT) { 4705 uint64_t fpscr; 4706 for (i = 0; i < ARRAY_SIZE(env->fpr); i++) { 4707 __get_user(env->fpr[i], &frame->mc_fregs[i]); 4708 } 4709 __get_user(fpscr, &frame->mc_fregs[32]); 4710 env->fpscr = (uint32_t) fpscr; 4711 } 4712 4713 /* Save SPE registers. The kernel only saves the high half. */ 4714 if (env->insns_flags & PPC_SPE) { 4715 #if defined(TARGET_PPC64) 4716 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) { 4717 uint32_t hi; 4718 4719 __get_user(hi, &frame->mc_vregs.spe[i]); 4720 env->gpr[i] = ((uint64_t)hi << 32) | ((uint32_t) env->gpr[i]); 4721 } 4722 #else 4723 for (i = 0; i < ARRAY_SIZE(env->gprh); i++) { 4724 __get_user(env->gprh[i], &frame->mc_vregs.spe[i]); 4725 } 4726 #endif 4727 __get_user(env->spe_fscr, &frame->mc_vregs.spe[32]); 4728 } 4729 } 4730 4731 static void setup_frame(int sig, struct target_sigaction *ka, 4732 target_sigset_t *set, CPUPPCState *env) 4733 { 4734 struct target_sigframe *frame; 4735 struct target_sigcontext *sc; 4736 target_ulong frame_addr, newsp; 4737 int err = 0; 4738 #if defined(TARGET_PPC64) 4739 struct image_info *image = ((TaskState *)thread_cpu->opaque)->info; 4740 #endif 4741 4742 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 4743 trace_user_setup_frame(env, frame_addr); 4744 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1)) 4745 goto sigsegv; 4746 sc = &frame->sctx; 4747 4748 __put_user(ka->_sa_handler, &sc->handler); 4749 __put_user(set->sig[0], &sc->oldmask); 4750 #if TARGET_ABI_BITS == 64 4751 __put_user(set->sig[0] >> 32, &sc->_unused[3]); 4752 #else 4753 __put_user(set->sig[1], &sc->_unused[3]); 4754 #endif 4755 __put_user(h2g(&frame->mctx), &sc->regs); 4756 __put_user(sig, &sc->signal); 4757 4758 /* Save user regs. */ 4759 save_user_regs(env, &frame->mctx); 4760 4761 /* Construct the trampoline code on the stack. */ 4762 encode_trampoline(TARGET_NR_sigreturn, (uint32_t *)&frame->mctx.tramp); 4763 4764 /* The kernel checks for the presence of a VDSO here. We don't 4765 emulate a vdso, so use a sigreturn system call. */ 4766 env->lr = (target_ulong) h2g(frame->mctx.tramp); 4767 4768 /* Turn off all fp exceptions. */ 4769 env->fpscr = 0; 4770 4771 /* Create a stack frame for the caller of the handler. */ 4772 newsp = frame_addr - SIGNAL_FRAMESIZE; 4773 err |= put_user(env->gpr[1], newsp, target_ulong); 4774 4775 if (err) 4776 goto sigsegv; 4777 4778 /* Set up registers for signal handler. */ 4779 env->gpr[1] = newsp; 4780 env->gpr[3] = sig; 4781 env->gpr[4] = frame_addr + offsetof(struct target_sigframe, sctx); 4782 4783 #if defined(TARGET_PPC64) 4784 if (get_ppc64_abi(image) < 2) { 4785 /* ELFv1 PPC64 function pointers are pointers to OPD entries. */ 4786 struct target_func_ptr *handler = 4787 (struct target_func_ptr *)g2h(ka->_sa_handler); 4788 env->nip = tswapl(handler->entry); 4789 env->gpr[2] = tswapl(handler->toc); 4790 } else { 4791 /* ELFv2 PPC64 function pointers are entry points, but R12 4792 * must also be set */ 4793 env->nip = tswapl((target_ulong) ka->_sa_handler); 4794 env->gpr[12] = env->nip; 4795 } 4796 #else 4797 env->nip = (target_ulong) ka->_sa_handler; 4798 #endif 4799 4800 /* Signal handlers are entered in big-endian mode. */ 4801 env->msr &= ~(1ull << MSR_LE); 4802 4803 unlock_user_struct(frame, frame_addr, 1); 4804 return; 4805 4806 sigsegv: 4807 unlock_user_struct(frame, frame_addr, 1); 4808 force_sig(TARGET_SIGSEGV); 4809 } 4810 4811 static void setup_rt_frame(int sig, struct target_sigaction *ka, 4812 target_siginfo_t *info, 4813 target_sigset_t *set, CPUPPCState *env) 4814 { 4815 struct target_rt_sigframe *rt_sf; 4816 uint32_t *trampptr = 0; 4817 struct target_mcontext *mctx = 0; 4818 target_ulong rt_sf_addr, newsp = 0; 4819 int i, err = 0; 4820 #if defined(TARGET_PPC64) 4821 struct image_info *image = ((TaskState *)thread_cpu->opaque)->info; 4822 #endif 4823 4824 rt_sf_addr = get_sigframe(ka, env, sizeof(*rt_sf)); 4825 if (!lock_user_struct(VERIFY_WRITE, rt_sf, rt_sf_addr, 1)) 4826 goto sigsegv; 4827 4828 tswap_siginfo(&rt_sf->info, info); 4829 4830 __put_user(0, &rt_sf->uc.tuc_flags); 4831 __put_user(0, &rt_sf->uc.tuc_link); 4832 __put_user((target_ulong)target_sigaltstack_used.ss_sp, 4833 &rt_sf->uc.tuc_stack.ss_sp); 4834 __put_user(sas_ss_flags(env->gpr[1]), 4835 &rt_sf->uc.tuc_stack.ss_flags); 4836 __put_user(target_sigaltstack_used.ss_size, 4837 &rt_sf->uc.tuc_stack.ss_size); 4838 #if !defined(TARGET_PPC64) 4839 __put_user(h2g (&rt_sf->uc.tuc_mcontext), 4840 &rt_sf->uc.tuc_regs); 4841 #endif 4842 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 4843 __put_user(set->sig[i], &rt_sf->uc.tuc_sigmask.sig[i]); 4844 } 4845 4846 #if defined(TARGET_PPC64) 4847 mctx = &rt_sf->uc.tuc_sigcontext.mcontext; 4848 trampptr = &rt_sf->trampoline[0]; 4849 #else 4850 mctx = &rt_sf->uc.tuc_mcontext; 4851 trampptr = (uint32_t *)&rt_sf->uc.tuc_mcontext.tramp; 4852 #endif 4853 4854 save_user_regs(env, mctx); 4855 encode_trampoline(TARGET_NR_rt_sigreturn, trampptr); 4856 4857 /* The kernel checks for the presence of a VDSO here. We don't 4858 emulate a vdso, so use a sigreturn system call. */ 4859 env->lr = (target_ulong) h2g(trampptr); 4860 4861 /* Turn off all fp exceptions. */ 4862 env->fpscr = 0; 4863 4864 /* Create a stack frame for the caller of the handler. */ 4865 newsp = rt_sf_addr - (SIGNAL_FRAMESIZE + 16); 4866 err |= put_user(env->gpr[1], newsp, target_ulong); 4867 4868 if (err) 4869 goto sigsegv; 4870 4871 /* Set up registers for signal handler. */ 4872 env->gpr[1] = newsp; 4873 env->gpr[3] = (target_ulong) sig; 4874 env->gpr[4] = (target_ulong) h2g(&rt_sf->info); 4875 env->gpr[5] = (target_ulong) h2g(&rt_sf->uc); 4876 env->gpr[6] = (target_ulong) h2g(rt_sf); 4877 4878 #if defined(TARGET_PPC64) 4879 if (get_ppc64_abi(image) < 2) { 4880 /* ELFv1 PPC64 function pointers are pointers to OPD entries. */ 4881 struct target_func_ptr *handler = 4882 (struct target_func_ptr *)g2h(ka->_sa_handler); 4883 env->nip = tswapl(handler->entry); 4884 env->gpr[2] = tswapl(handler->toc); 4885 } else { 4886 /* ELFv2 PPC64 function pointers are entry points, but R12 4887 * must also be set */ 4888 env->nip = tswapl((target_ulong) ka->_sa_handler); 4889 env->gpr[12] = env->nip; 4890 } 4891 #else 4892 env->nip = (target_ulong) ka->_sa_handler; 4893 #endif 4894 4895 /* Signal handlers are entered in big-endian mode. */ 4896 env->msr &= ~(1ull << MSR_LE); 4897 4898 unlock_user_struct(rt_sf, rt_sf_addr, 1); 4899 return; 4900 4901 sigsegv: 4902 unlock_user_struct(rt_sf, rt_sf_addr, 1); 4903 force_sig(TARGET_SIGSEGV); 4904 4905 } 4906 4907 long do_sigreturn(CPUPPCState *env) 4908 { 4909 struct target_sigcontext *sc = NULL; 4910 struct target_mcontext *sr = NULL; 4911 target_ulong sr_addr = 0, sc_addr; 4912 sigset_t blocked; 4913 target_sigset_t set; 4914 4915 sc_addr = env->gpr[1] + SIGNAL_FRAMESIZE; 4916 if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1)) 4917 goto sigsegv; 4918 4919 #if defined(TARGET_PPC64) 4920 set.sig[0] = sc->oldmask + ((uint64_t)(sc->_unused[3]) << 32); 4921 #else 4922 __get_user(set.sig[0], &sc->oldmask); 4923 __get_user(set.sig[1], &sc->_unused[3]); 4924 #endif 4925 target_to_host_sigset_internal(&blocked, &set); 4926 set_sigmask(&blocked); 4927 4928 __get_user(sr_addr, &sc->regs); 4929 if (!lock_user_struct(VERIFY_READ, sr, sr_addr, 1)) 4930 goto sigsegv; 4931 restore_user_regs(env, sr, 1); 4932 4933 unlock_user_struct(sr, sr_addr, 1); 4934 unlock_user_struct(sc, sc_addr, 1); 4935 return -TARGET_QEMU_ESIGRETURN; 4936 4937 sigsegv: 4938 unlock_user_struct(sr, sr_addr, 1); 4939 unlock_user_struct(sc, sc_addr, 1); 4940 force_sig(TARGET_SIGSEGV); 4941 return 0; 4942 } 4943 4944 /* See arch/powerpc/kernel/signal_32.c. */ 4945 static int do_setcontext(struct target_ucontext *ucp, CPUPPCState *env, int sig) 4946 { 4947 struct target_mcontext *mcp; 4948 target_ulong mcp_addr; 4949 sigset_t blocked; 4950 target_sigset_t set; 4951 4952 if (copy_from_user(&set, h2g(ucp) + offsetof(struct target_ucontext, tuc_sigmask), 4953 sizeof (set))) 4954 return 1; 4955 4956 #if defined(TARGET_PPC64) 4957 mcp_addr = h2g(ucp) + 4958 offsetof(struct target_ucontext, tuc_sigcontext.mcontext); 4959 #else 4960 __get_user(mcp_addr, &ucp->tuc_regs); 4961 #endif 4962 4963 if (!lock_user_struct(VERIFY_READ, mcp, mcp_addr, 1)) 4964 return 1; 4965 4966 target_to_host_sigset_internal(&blocked, &set); 4967 set_sigmask(&blocked); 4968 restore_user_regs(env, mcp, sig); 4969 4970 unlock_user_struct(mcp, mcp_addr, 1); 4971 return 0; 4972 } 4973 4974 long do_rt_sigreturn(CPUPPCState *env) 4975 { 4976 struct target_rt_sigframe *rt_sf = NULL; 4977 target_ulong rt_sf_addr; 4978 4979 rt_sf_addr = env->gpr[1] + SIGNAL_FRAMESIZE + 16; 4980 if (!lock_user_struct(VERIFY_READ, rt_sf, rt_sf_addr, 1)) 4981 goto sigsegv; 4982 4983 if (do_setcontext(&rt_sf->uc, env, 1)) 4984 goto sigsegv; 4985 4986 do_sigaltstack(rt_sf_addr 4987 + offsetof(struct target_rt_sigframe, uc.tuc_stack), 4988 0, env->gpr[1]); 4989 4990 unlock_user_struct(rt_sf, rt_sf_addr, 1); 4991 return -TARGET_QEMU_ESIGRETURN; 4992 4993 sigsegv: 4994 unlock_user_struct(rt_sf, rt_sf_addr, 1); 4995 force_sig(TARGET_SIGSEGV); 4996 return 0; 4997 } 4998 4999 #elif defined(TARGET_M68K) 5000 5001 struct target_sigcontext { 5002 abi_ulong sc_mask; 5003 abi_ulong sc_usp; 5004 abi_ulong sc_d0; 5005 abi_ulong sc_d1; 5006 abi_ulong sc_a0; 5007 abi_ulong sc_a1; 5008 unsigned short sc_sr; 5009 abi_ulong sc_pc; 5010 }; 5011 5012 struct target_sigframe 5013 { 5014 abi_ulong pretcode; 5015 int sig; 5016 int code; 5017 abi_ulong psc; 5018 char retcode[8]; 5019 abi_ulong extramask[TARGET_NSIG_WORDS-1]; 5020 struct target_sigcontext sc; 5021 }; 5022 5023 typedef int target_greg_t; 5024 #define TARGET_NGREG 18 5025 typedef target_greg_t target_gregset_t[TARGET_NGREG]; 5026 5027 typedef struct target_fpregset { 5028 int f_fpcntl[3]; 5029 int f_fpregs[8*3]; 5030 } target_fpregset_t; 5031 5032 struct target_mcontext { 5033 int version; 5034 target_gregset_t gregs; 5035 target_fpregset_t fpregs; 5036 }; 5037 5038 #define TARGET_MCONTEXT_VERSION 2 5039 5040 struct target_ucontext { 5041 abi_ulong tuc_flags; 5042 abi_ulong tuc_link; 5043 target_stack_t tuc_stack; 5044 struct target_mcontext tuc_mcontext; 5045 abi_long tuc_filler[80]; 5046 target_sigset_t tuc_sigmask; 5047 }; 5048 5049 struct target_rt_sigframe 5050 { 5051 abi_ulong pretcode; 5052 int sig; 5053 abi_ulong pinfo; 5054 abi_ulong puc; 5055 char retcode[8]; 5056 struct target_siginfo info; 5057 struct target_ucontext uc; 5058 }; 5059 5060 static void setup_sigcontext(struct target_sigcontext *sc, CPUM68KState *env, 5061 abi_ulong mask) 5062 { 5063 __put_user(mask, &sc->sc_mask); 5064 __put_user(env->aregs[7], &sc->sc_usp); 5065 __put_user(env->dregs[0], &sc->sc_d0); 5066 __put_user(env->dregs[1], &sc->sc_d1); 5067 __put_user(env->aregs[0], &sc->sc_a0); 5068 __put_user(env->aregs[1], &sc->sc_a1); 5069 __put_user(env->sr, &sc->sc_sr); 5070 __put_user(env->pc, &sc->sc_pc); 5071 } 5072 5073 static void 5074 restore_sigcontext(CPUM68KState *env, struct target_sigcontext *sc) 5075 { 5076 int temp; 5077 5078 __get_user(env->aregs[7], &sc->sc_usp); 5079 __get_user(env->dregs[0], &sc->sc_d0); 5080 __get_user(env->dregs[1], &sc->sc_d1); 5081 __get_user(env->aregs[0], &sc->sc_a0); 5082 __get_user(env->aregs[1], &sc->sc_a1); 5083 __get_user(env->pc, &sc->sc_pc); 5084 __get_user(temp, &sc->sc_sr); 5085 env->sr = (env->sr & 0xff00) | (temp & 0xff); 5086 } 5087 5088 /* 5089 * Determine which stack to use.. 5090 */ 5091 static inline abi_ulong 5092 get_sigframe(struct target_sigaction *ka, CPUM68KState *regs, 5093 size_t frame_size) 5094 { 5095 unsigned long sp; 5096 5097 sp = regs->aregs[7]; 5098 5099 /* This is the X/Open sanctioned signal stack switching. */ 5100 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) { 5101 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 5102 } 5103 5104 return ((sp - frame_size) & -8UL); 5105 } 5106 5107 static void setup_frame(int sig, struct target_sigaction *ka, 5108 target_sigset_t *set, CPUM68KState *env) 5109 { 5110 struct target_sigframe *frame; 5111 abi_ulong frame_addr; 5112 abi_ulong retcode_addr; 5113 abi_ulong sc_addr; 5114 int i; 5115 5116 frame_addr = get_sigframe(ka, env, sizeof *frame); 5117 trace_user_setup_frame(env, frame_addr); 5118 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 5119 goto give_sigsegv; 5120 } 5121 5122 __put_user(sig, &frame->sig); 5123 5124 sc_addr = frame_addr + offsetof(struct target_sigframe, sc); 5125 __put_user(sc_addr, &frame->psc); 5126 5127 setup_sigcontext(&frame->sc, env, set->sig[0]); 5128 5129 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 5130 __put_user(set->sig[i], &frame->extramask[i - 1]); 5131 } 5132 5133 /* Set up to return from userspace. */ 5134 5135 retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode); 5136 __put_user(retcode_addr, &frame->pretcode); 5137 5138 /* moveq #,d0; trap #0 */ 5139 5140 __put_user(0x70004e40 + (TARGET_NR_sigreturn << 16), 5141 (uint32_t *)(frame->retcode)); 5142 5143 /* Set up to return from userspace */ 5144 5145 env->aregs[7] = frame_addr; 5146 env->pc = ka->_sa_handler; 5147 5148 unlock_user_struct(frame, frame_addr, 1); 5149 return; 5150 5151 give_sigsegv: 5152 force_sig(TARGET_SIGSEGV); 5153 } 5154 5155 static inline int target_rt_setup_ucontext(struct target_ucontext *uc, 5156 CPUM68KState *env) 5157 { 5158 target_greg_t *gregs = uc->tuc_mcontext.gregs; 5159 5160 __put_user(TARGET_MCONTEXT_VERSION, &uc->tuc_mcontext.version); 5161 __put_user(env->dregs[0], &gregs[0]); 5162 __put_user(env->dregs[1], &gregs[1]); 5163 __put_user(env->dregs[2], &gregs[2]); 5164 __put_user(env->dregs[3], &gregs[3]); 5165 __put_user(env->dregs[4], &gregs[4]); 5166 __put_user(env->dregs[5], &gregs[5]); 5167 __put_user(env->dregs[6], &gregs[6]); 5168 __put_user(env->dregs[7], &gregs[7]); 5169 __put_user(env->aregs[0], &gregs[8]); 5170 __put_user(env->aregs[1], &gregs[9]); 5171 __put_user(env->aregs[2], &gregs[10]); 5172 __put_user(env->aregs[3], &gregs[11]); 5173 __put_user(env->aregs[4], &gregs[12]); 5174 __put_user(env->aregs[5], &gregs[13]); 5175 __put_user(env->aregs[6], &gregs[14]); 5176 __put_user(env->aregs[7], &gregs[15]); 5177 __put_user(env->pc, &gregs[16]); 5178 __put_user(env->sr, &gregs[17]); 5179 5180 return 0; 5181 } 5182 5183 static inline int target_rt_restore_ucontext(CPUM68KState *env, 5184 struct target_ucontext *uc) 5185 { 5186 int temp; 5187 target_greg_t *gregs = uc->tuc_mcontext.gregs; 5188 5189 __get_user(temp, &uc->tuc_mcontext.version); 5190 if (temp != TARGET_MCONTEXT_VERSION) 5191 goto badframe; 5192 5193 /* restore passed registers */ 5194 __get_user(env->dregs[0], &gregs[0]); 5195 __get_user(env->dregs[1], &gregs[1]); 5196 __get_user(env->dregs[2], &gregs[2]); 5197 __get_user(env->dregs[3], &gregs[3]); 5198 __get_user(env->dregs[4], &gregs[4]); 5199 __get_user(env->dregs[5], &gregs[5]); 5200 __get_user(env->dregs[6], &gregs[6]); 5201 __get_user(env->dregs[7], &gregs[7]); 5202 __get_user(env->aregs[0], &gregs[8]); 5203 __get_user(env->aregs[1], &gregs[9]); 5204 __get_user(env->aregs[2], &gregs[10]); 5205 __get_user(env->aregs[3], &gregs[11]); 5206 __get_user(env->aregs[4], &gregs[12]); 5207 __get_user(env->aregs[5], &gregs[13]); 5208 __get_user(env->aregs[6], &gregs[14]); 5209 __get_user(env->aregs[7], &gregs[15]); 5210 __get_user(env->pc, &gregs[16]); 5211 __get_user(temp, &gregs[17]); 5212 env->sr = (env->sr & 0xff00) | (temp & 0xff); 5213 5214 return 0; 5215 5216 badframe: 5217 return 1; 5218 } 5219 5220 static void setup_rt_frame(int sig, struct target_sigaction *ka, 5221 target_siginfo_t *info, 5222 target_sigset_t *set, CPUM68KState *env) 5223 { 5224 struct target_rt_sigframe *frame; 5225 abi_ulong frame_addr; 5226 abi_ulong retcode_addr; 5227 abi_ulong info_addr; 5228 abi_ulong uc_addr; 5229 int err = 0; 5230 int i; 5231 5232 frame_addr = get_sigframe(ka, env, sizeof *frame); 5233 trace_user_setup_rt_frame(env, frame_addr); 5234 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 5235 goto give_sigsegv; 5236 } 5237 5238 __put_user(sig, &frame->sig); 5239 5240 info_addr = frame_addr + offsetof(struct target_rt_sigframe, info); 5241 __put_user(info_addr, &frame->pinfo); 5242 5243 uc_addr = frame_addr + offsetof(struct target_rt_sigframe, uc); 5244 __put_user(uc_addr, &frame->puc); 5245 5246 tswap_siginfo(&frame->info, info); 5247 5248 /* Create the ucontext */ 5249 5250 __put_user(0, &frame->uc.tuc_flags); 5251 __put_user(0, &frame->uc.tuc_link); 5252 __put_user(target_sigaltstack_used.ss_sp, 5253 &frame->uc.tuc_stack.ss_sp); 5254 __put_user(sas_ss_flags(env->aregs[7]), 5255 &frame->uc.tuc_stack.ss_flags); 5256 __put_user(target_sigaltstack_used.ss_size, 5257 &frame->uc.tuc_stack.ss_size); 5258 err |= target_rt_setup_ucontext(&frame->uc, env); 5259 5260 if (err) 5261 goto give_sigsegv; 5262 5263 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 5264 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]); 5265 } 5266 5267 /* Set up to return from userspace. */ 5268 5269 retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode); 5270 __put_user(retcode_addr, &frame->pretcode); 5271 5272 /* moveq #,d0; notb d0; trap #0 */ 5273 5274 __put_user(0x70004600 + ((TARGET_NR_rt_sigreturn ^ 0xff) << 16), 5275 (uint32_t *)(frame->retcode + 0)); 5276 __put_user(0x4e40, (uint16_t *)(frame->retcode + 4)); 5277 5278 if (err) 5279 goto give_sigsegv; 5280 5281 /* Set up to return from userspace */ 5282 5283 env->aregs[7] = frame_addr; 5284 env->pc = ka->_sa_handler; 5285 5286 unlock_user_struct(frame, frame_addr, 1); 5287 return; 5288 5289 give_sigsegv: 5290 unlock_user_struct(frame, frame_addr, 1); 5291 force_sig(TARGET_SIGSEGV); 5292 } 5293 5294 long do_sigreturn(CPUM68KState *env) 5295 { 5296 struct target_sigframe *frame; 5297 abi_ulong frame_addr = env->aregs[7] - 4; 5298 target_sigset_t target_set; 5299 sigset_t set; 5300 int i; 5301 5302 trace_user_do_sigreturn(env, frame_addr); 5303 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 5304 goto badframe; 5305 5306 /* set blocked signals */ 5307 5308 __get_user(target_set.sig[0], &frame->sc.sc_mask); 5309 5310 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 5311 __get_user(target_set.sig[i], &frame->extramask[i - 1]); 5312 } 5313 5314 target_to_host_sigset_internal(&set, &target_set); 5315 set_sigmask(&set); 5316 5317 /* restore registers */ 5318 5319 restore_sigcontext(env, &frame->sc); 5320 5321 unlock_user_struct(frame, frame_addr, 0); 5322 return -TARGET_QEMU_ESIGRETURN; 5323 5324 badframe: 5325 force_sig(TARGET_SIGSEGV); 5326 return 0; 5327 } 5328 5329 long do_rt_sigreturn(CPUM68KState *env) 5330 { 5331 struct target_rt_sigframe *frame; 5332 abi_ulong frame_addr = env->aregs[7] - 4; 5333 target_sigset_t target_set; 5334 sigset_t set; 5335 5336 trace_user_do_rt_sigreturn(env, frame_addr); 5337 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 5338 goto badframe; 5339 5340 target_to_host_sigset_internal(&set, &target_set); 5341 set_sigmask(&set); 5342 5343 /* restore registers */ 5344 5345 if (target_rt_restore_ucontext(env, &frame->uc)) 5346 goto badframe; 5347 5348 if (do_sigaltstack(frame_addr + 5349 offsetof(struct target_rt_sigframe, uc.tuc_stack), 5350 0, get_sp_from_cpustate(env)) == -EFAULT) 5351 goto badframe; 5352 5353 unlock_user_struct(frame, frame_addr, 0); 5354 return -TARGET_QEMU_ESIGRETURN; 5355 5356 badframe: 5357 unlock_user_struct(frame, frame_addr, 0); 5358 force_sig(TARGET_SIGSEGV); 5359 return 0; 5360 } 5361 5362 #elif defined(TARGET_ALPHA) 5363 5364 struct target_sigcontext { 5365 abi_long sc_onstack; 5366 abi_long sc_mask; 5367 abi_long sc_pc; 5368 abi_long sc_ps; 5369 abi_long sc_regs[32]; 5370 abi_long sc_ownedfp; 5371 abi_long sc_fpregs[32]; 5372 abi_ulong sc_fpcr; 5373 abi_ulong sc_fp_control; 5374 abi_ulong sc_reserved1; 5375 abi_ulong sc_reserved2; 5376 abi_ulong sc_ssize; 5377 abi_ulong sc_sbase; 5378 abi_ulong sc_traparg_a0; 5379 abi_ulong sc_traparg_a1; 5380 abi_ulong sc_traparg_a2; 5381 abi_ulong sc_fp_trap_pc; 5382 abi_ulong sc_fp_trigger_sum; 5383 abi_ulong sc_fp_trigger_inst; 5384 }; 5385 5386 struct target_ucontext { 5387 abi_ulong tuc_flags; 5388 abi_ulong tuc_link; 5389 abi_ulong tuc_osf_sigmask; 5390 target_stack_t tuc_stack; 5391 struct target_sigcontext tuc_mcontext; 5392 target_sigset_t tuc_sigmask; 5393 }; 5394 5395 struct target_sigframe { 5396 struct target_sigcontext sc; 5397 unsigned int retcode[3]; 5398 }; 5399 5400 struct target_rt_sigframe { 5401 target_siginfo_t info; 5402 struct target_ucontext uc; 5403 unsigned int retcode[3]; 5404 }; 5405 5406 #define INSN_MOV_R30_R16 0x47fe0410 5407 #define INSN_LDI_R0 0x201f0000 5408 #define INSN_CALLSYS 0x00000083 5409 5410 static void setup_sigcontext(struct target_sigcontext *sc, CPUAlphaState *env, 5411 abi_ulong frame_addr, target_sigset_t *set) 5412 { 5413 int i; 5414 5415 __put_user(on_sig_stack(frame_addr), &sc->sc_onstack); 5416 __put_user(set->sig[0], &sc->sc_mask); 5417 __put_user(env->pc, &sc->sc_pc); 5418 __put_user(8, &sc->sc_ps); 5419 5420 for (i = 0; i < 31; ++i) { 5421 __put_user(env->ir[i], &sc->sc_regs[i]); 5422 } 5423 __put_user(0, &sc->sc_regs[31]); 5424 5425 for (i = 0; i < 31; ++i) { 5426 __put_user(env->fir[i], &sc->sc_fpregs[i]); 5427 } 5428 __put_user(0, &sc->sc_fpregs[31]); 5429 __put_user(cpu_alpha_load_fpcr(env), &sc->sc_fpcr); 5430 5431 __put_user(0, &sc->sc_traparg_a0); /* FIXME */ 5432 __put_user(0, &sc->sc_traparg_a1); /* FIXME */ 5433 __put_user(0, &sc->sc_traparg_a2); /* FIXME */ 5434 } 5435 5436 static void restore_sigcontext(CPUAlphaState *env, 5437 struct target_sigcontext *sc) 5438 { 5439 uint64_t fpcr; 5440 int i; 5441 5442 __get_user(env->pc, &sc->sc_pc); 5443 5444 for (i = 0; i < 31; ++i) { 5445 __get_user(env->ir[i], &sc->sc_regs[i]); 5446 } 5447 for (i = 0; i < 31; ++i) { 5448 __get_user(env->fir[i], &sc->sc_fpregs[i]); 5449 } 5450 5451 __get_user(fpcr, &sc->sc_fpcr); 5452 cpu_alpha_store_fpcr(env, fpcr); 5453 } 5454 5455 static inline abi_ulong get_sigframe(struct target_sigaction *sa, 5456 CPUAlphaState *env, 5457 unsigned long framesize) 5458 { 5459 abi_ulong sp = env->ir[IR_SP]; 5460 5461 /* This is the X/Open sanctioned signal stack switching. */ 5462 if ((sa->sa_flags & TARGET_SA_ONSTACK) != 0 && !sas_ss_flags(sp)) { 5463 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 5464 } 5465 return (sp - framesize) & -32; 5466 } 5467 5468 static void setup_frame(int sig, struct target_sigaction *ka, 5469 target_sigset_t *set, CPUAlphaState *env) 5470 { 5471 abi_ulong frame_addr, r26; 5472 struct target_sigframe *frame; 5473 int err = 0; 5474 5475 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 5476 trace_user_setup_frame(env, frame_addr); 5477 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 5478 goto give_sigsegv; 5479 } 5480 5481 setup_sigcontext(&frame->sc, env, frame_addr, set); 5482 5483 if (ka->sa_restorer) { 5484 r26 = ka->sa_restorer; 5485 } else { 5486 __put_user(INSN_MOV_R30_R16, &frame->retcode[0]); 5487 __put_user(INSN_LDI_R0 + TARGET_NR_sigreturn, 5488 &frame->retcode[1]); 5489 __put_user(INSN_CALLSYS, &frame->retcode[2]); 5490 /* imb() */ 5491 r26 = frame_addr; 5492 } 5493 5494 unlock_user_struct(frame, frame_addr, 1); 5495 5496 if (err) { 5497 give_sigsegv: 5498 if (sig == TARGET_SIGSEGV) { 5499 ka->_sa_handler = TARGET_SIG_DFL; 5500 } 5501 force_sig(TARGET_SIGSEGV); 5502 } 5503 5504 env->ir[IR_RA] = r26; 5505 env->ir[IR_PV] = env->pc = ka->_sa_handler; 5506 env->ir[IR_A0] = sig; 5507 env->ir[IR_A1] = 0; 5508 env->ir[IR_A2] = frame_addr + offsetof(struct target_sigframe, sc); 5509 env->ir[IR_SP] = frame_addr; 5510 } 5511 5512 static void setup_rt_frame(int sig, struct target_sigaction *ka, 5513 target_siginfo_t *info, 5514 target_sigset_t *set, CPUAlphaState *env) 5515 { 5516 abi_ulong frame_addr, r26; 5517 struct target_rt_sigframe *frame; 5518 int i, err = 0; 5519 5520 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 5521 trace_user_setup_rt_frame(env, frame_addr); 5522 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 5523 goto give_sigsegv; 5524 } 5525 5526 tswap_siginfo(&frame->info, info); 5527 5528 __put_user(0, &frame->uc.tuc_flags); 5529 __put_user(0, &frame->uc.tuc_link); 5530 __put_user(set->sig[0], &frame->uc.tuc_osf_sigmask); 5531 __put_user(target_sigaltstack_used.ss_sp, 5532 &frame->uc.tuc_stack.ss_sp); 5533 __put_user(sas_ss_flags(env->ir[IR_SP]), 5534 &frame->uc.tuc_stack.ss_flags); 5535 __put_user(target_sigaltstack_used.ss_size, 5536 &frame->uc.tuc_stack.ss_size); 5537 setup_sigcontext(&frame->uc.tuc_mcontext, env, frame_addr, set); 5538 for (i = 0; i < TARGET_NSIG_WORDS; ++i) { 5539 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]); 5540 } 5541 5542 if (ka->sa_restorer) { 5543 r26 = ka->sa_restorer; 5544 } else { 5545 __put_user(INSN_MOV_R30_R16, &frame->retcode[0]); 5546 __put_user(INSN_LDI_R0 + TARGET_NR_rt_sigreturn, 5547 &frame->retcode[1]); 5548 __put_user(INSN_CALLSYS, &frame->retcode[2]); 5549 /* imb(); */ 5550 r26 = frame_addr; 5551 } 5552 5553 if (err) { 5554 give_sigsegv: 5555 if (sig == TARGET_SIGSEGV) { 5556 ka->_sa_handler = TARGET_SIG_DFL; 5557 } 5558 force_sig(TARGET_SIGSEGV); 5559 } 5560 5561 env->ir[IR_RA] = r26; 5562 env->ir[IR_PV] = env->pc = ka->_sa_handler; 5563 env->ir[IR_A0] = sig; 5564 env->ir[IR_A1] = frame_addr + offsetof(struct target_rt_sigframe, info); 5565 env->ir[IR_A2] = frame_addr + offsetof(struct target_rt_sigframe, uc); 5566 env->ir[IR_SP] = frame_addr; 5567 } 5568 5569 long do_sigreturn(CPUAlphaState *env) 5570 { 5571 struct target_sigcontext *sc; 5572 abi_ulong sc_addr = env->ir[IR_A0]; 5573 target_sigset_t target_set; 5574 sigset_t set; 5575 5576 if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1)) { 5577 goto badframe; 5578 } 5579 5580 target_sigemptyset(&target_set); 5581 __get_user(target_set.sig[0], &sc->sc_mask); 5582 5583 target_to_host_sigset_internal(&set, &target_set); 5584 set_sigmask(&set); 5585 5586 restore_sigcontext(env, sc); 5587 unlock_user_struct(sc, sc_addr, 0); 5588 return -TARGET_QEMU_ESIGRETURN; 5589 5590 badframe: 5591 force_sig(TARGET_SIGSEGV); 5592 } 5593 5594 long do_rt_sigreturn(CPUAlphaState *env) 5595 { 5596 abi_ulong frame_addr = env->ir[IR_A0]; 5597 struct target_rt_sigframe *frame; 5598 sigset_t set; 5599 5600 trace_user_do_rt_sigreturn(env, frame_addr); 5601 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) { 5602 goto badframe; 5603 } 5604 target_to_host_sigset(&set, &frame->uc.tuc_sigmask); 5605 set_sigmask(&set); 5606 5607 restore_sigcontext(env, &frame->uc.tuc_mcontext); 5608 if (do_sigaltstack(frame_addr + offsetof(struct target_rt_sigframe, 5609 uc.tuc_stack), 5610 0, env->ir[IR_SP]) == -EFAULT) { 5611 goto badframe; 5612 } 5613 5614 unlock_user_struct(frame, frame_addr, 0); 5615 return -TARGET_QEMU_ESIGRETURN; 5616 5617 5618 badframe: 5619 unlock_user_struct(frame, frame_addr, 0); 5620 force_sig(TARGET_SIGSEGV); 5621 } 5622 5623 #elif defined(TARGET_TILEGX) 5624 5625 struct target_sigcontext { 5626 union { 5627 /* General-purpose registers. */ 5628 abi_ulong gregs[56]; 5629 struct { 5630 abi_ulong __gregs[53]; 5631 abi_ulong tp; /* Aliases gregs[TREG_TP]. */ 5632 abi_ulong sp; /* Aliases gregs[TREG_SP]. */ 5633 abi_ulong lr; /* Aliases gregs[TREG_LR]. */ 5634 }; 5635 }; 5636 abi_ulong pc; /* Program counter. */ 5637 abi_ulong ics; /* In Interrupt Critical Section? */ 5638 abi_ulong faultnum; /* Fault number. */ 5639 abi_ulong pad[5]; 5640 }; 5641 5642 struct target_ucontext { 5643 abi_ulong tuc_flags; 5644 abi_ulong tuc_link; 5645 target_stack_t tuc_stack; 5646 struct target_sigcontext tuc_mcontext; 5647 target_sigset_t tuc_sigmask; /* mask last for extensibility */ 5648 }; 5649 5650 struct target_rt_sigframe { 5651 unsigned char save_area[16]; /* caller save area */ 5652 struct target_siginfo info; 5653 struct target_ucontext uc; 5654 abi_ulong retcode[2]; 5655 }; 5656 5657 #define INSN_MOVELI_R10_139 0x00045fe551483000ULL /* { moveli r10, 139 } */ 5658 #define INSN_SWINT1 0x286b180051485000ULL /* { swint1 } */ 5659 5660 5661 static void setup_sigcontext(struct target_sigcontext *sc, 5662 CPUArchState *env, int signo) 5663 { 5664 int i; 5665 5666 for (i = 0; i < TILEGX_R_COUNT; ++i) { 5667 __put_user(env->regs[i], &sc->gregs[i]); 5668 } 5669 5670 __put_user(env->pc, &sc->pc); 5671 __put_user(0, &sc->ics); 5672 __put_user(signo, &sc->faultnum); 5673 } 5674 5675 static void restore_sigcontext(CPUTLGState *env, struct target_sigcontext *sc) 5676 { 5677 int i; 5678 5679 for (i = 0; i < TILEGX_R_COUNT; ++i) { 5680 __get_user(env->regs[i], &sc->gregs[i]); 5681 } 5682 5683 __get_user(env->pc, &sc->pc); 5684 } 5685 5686 static abi_ulong get_sigframe(struct target_sigaction *ka, CPUArchState *env, 5687 size_t frame_size) 5688 { 5689 unsigned long sp = env->regs[TILEGX_R_SP]; 5690 5691 if (on_sig_stack(sp) && !likely(on_sig_stack(sp - frame_size))) { 5692 return -1UL; 5693 } 5694 5695 if ((ka->sa_flags & SA_ONSTACK) && !sas_ss_flags(sp)) { 5696 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 5697 } 5698 5699 sp -= frame_size; 5700 sp &= -16UL; 5701 return sp; 5702 } 5703 5704 static void setup_rt_frame(int sig, struct target_sigaction *ka, 5705 target_siginfo_t *info, 5706 target_sigset_t *set, CPUArchState *env) 5707 { 5708 abi_ulong frame_addr; 5709 struct target_rt_sigframe *frame; 5710 unsigned long restorer; 5711 5712 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 5713 trace_user_setup_rt_frame(env, frame_addr); 5714 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 5715 goto give_sigsegv; 5716 } 5717 5718 /* Always write at least the signal number for the stack backtracer. */ 5719 if (ka->sa_flags & TARGET_SA_SIGINFO) { 5720 /* At sigreturn time, restore the callee-save registers too. */ 5721 tswap_siginfo(&frame->info, info); 5722 /* regs->flags |= PT_FLAGS_RESTORE_REGS; FIXME: we can skip it? */ 5723 } else { 5724 __put_user(info->si_signo, &frame->info.si_signo); 5725 } 5726 5727 /* Create the ucontext. */ 5728 __put_user(0, &frame->uc.tuc_flags); 5729 __put_user(0, &frame->uc.tuc_link); 5730 __put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp); 5731 __put_user(sas_ss_flags(env->regs[TILEGX_R_SP]), 5732 &frame->uc.tuc_stack.ss_flags); 5733 __put_user(target_sigaltstack_used.ss_size, &frame->uc.tuc_stack.ss_size); 5734 setup_sigcontext(&frame->uc.tuc_mcontext, env, info->si_signo); 5735 5736 if (ka->sa_flags & TARGET_SA_RESTORER) { 5737 restorer = (unsigned long) ka->sa_restorer; 5738 } else { 5739 __put_user(INSN_MOVELI_R10_139, &frame->retcode[0]); 5740 __put_user(INSN_SWINT1, &frame->retcode[1]); 5741 restorer = frame_addr + offsetof(struct target_rt_sigframe, retcode); 5742 } 5743 env->pc = (unsigned long) ka->_sa_handler; 5744 env->regs[TILEGX_R_SP] = (unsigned long) frame; 5745 env->regs[TILEGX_R_LR] = restorer; 5746 env->regs[0] = (unsigned long) sig; 5747 env->regs[1] = (unsigned long) &frame->info; 5748 env->regs[2] = (unsigned long) &frame->uc; 5749 /* regs->flags |= PT_FLAGS_CALLER_SAVES; FIXME: we can skip it? */ 5750 5751 unlock_user_struct(frame, frame_addr, 1); 5752 return; 5753 5754 give_sigsegv: 5755 if (sig == TARGET_SIGSEGV) { 5756 ka->_sa_handler = TARGET_SIG_DFL; 5757 } 5758 force_sig(TARGET_SIGSEGV /* , current */); 5759 } 5760 5761 long do_rt_sigreturn(CPUTLGState *env) 5762 { 5763 abi_ulong frame_addr = env->regs[TILEGX_R_SP]; 5764 struct target_rt_sigframe *frame; 5765 sigset_t set; 5766 5767 trace_user_do_rt_sigreturn(env, frame_addr); 5768 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) { 5769 goto badframe; 5770 } 5771 target_to_host_sigset(&set, &frame->uc.tuc_sigmask); 5772 set_sigmask(&set); 5773 5774 restore_sigcontext(env, &frame->uc.tuc_mcontext); 5775 if (do_sigaltstack(frame_addr + offsetof(struct target_rt_sigframe, 5776 uc.tuc_stack), 5777 0, env->regs[TILEGX_R_SP]) == -EFAULT) { 5778 goto badframe; 5779 } 5780 5781 unlock_user_struct(frame, frame_addr, 0); 5782 return -TARGET_QEMU_ESIGRETURN; 5783 5784 5785 badframe: 5786 unlock_user_struct(frame, frame_addr, 0); 5787 force_sig(TARGET_SIGSEGV); 5788 } 5789 5790 #else 5791 5792 static void setup_frame(int sig, struct target_sigaction *ka, 5793 target_sigset_t *set, CPUArchState *env) 5794 { 5795 fprintf(stderr, "setup_frame: not implemented\n"); 5796 } 5797 5798 static void setup_rt_frame(int sig, struct target_sigaction *ka, 5799 target_siginfo_t *info, 5800 target_sigset_t *set, CPUArchState *env) 5801 { 5802 fprintf(stderr, "setup_rt_frame: not implemented\n"); 5803 } 5804 5805 long do_sigreturn(CPUArchState *env) 5806 { 5807 fprintf(stderr, "do_sigreturn: not implemented\n"); 5808 return -TARGET_ENOSYS; 5809 } 5810 5811 long do_rt_sigreturn(CPUArchState *env) 5812 { 5813 fprintf(stderr, "do_rt_sigreturn: not implemented\n"); 5814 return -TARGET_ENOSYS; 5815 } 5816 5817 #endif 5818 5819 static void handle_pending_signal(CPUArchState *cpu_env, int sig) 5820 { 5821 CPUState *cpu = ENV_GET_CPU(cpu_env); 5822 abi_ulong handler; 5823 sigset_t set; 5824 target_sigset_t target_old_set; 5825 struct target_sigaction *sa; 5826 TaskState *ts = cpu->opaque; 5827 struct emulated_sigtable *k = &ts->sigtab[sig - 1]; 5828 5829 trace_user_handle_signal(cpu_env, sig); 5830 /* dequeue signal */ 5831 k->pending = 0; 5832 5833 sig = gdb_handlesig(cpu, sig); 5834 if (!sig) { 5835 sa = NULL; 5836 handler = TARGET_SIG_IGN; 5837 } else { 5838 sa = &sigact_table[sig - 1]; 5839 handler = sa->_sa_handler; 5840 } 5841 5842 if (handler == TARGET_SIG_DFL) { 5843 /* default handler : ignore some signal. The other are job control or fatal */ 5844 if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) { 5845 kill(getpid(),SIGSTOP); 5846 } else if (sig != TARGET_SIGCHLD && 5847 sig != TARGET_SIGURG && 5848 sig != TARGET_SIGWINCH && 5849 sig != TARGET_SIGCONT) { 5850 force_sig(sig); 5851 } 5852 } else if (handler == TARGET_SIG_IGN) { 5853 /* ignore sig */ 5854 } else if (handler == TARGET_SIG_ERR) { 5855 force_sig(sig); 5856 } else { 5857 /* compute the blocked signals during the handler execution */ 5858 sigset_t *blocked_set; 5859 5860 target_to_host_sigset(&set, &sa->sa_mask); 5861 /* SA_NODEFER indicates that the current signal should not be 5862 blocked during the handler */ 5863 if (!(sa->sa_flags & TARGET_SA_NODEFER)) 5864 sigaddset(&set, target_to_host_signal(sig)); 5865 5866 /* save the previous blocked signal state to restore it at the 5867 end of the signal execution (see do_sigreturn) */ 5868 host_to_target_sigset_internal(&target_old_set, &ts->signal_mask); 5869 5870 /* block signals in the handler */ 5871 blocked_set = ts->in_sigsuspend ? 5872 &ts->sigsuspend_mask : &ts->signal_mask; 5873 sigorset(&ts->signal_mask, blocked_set, &set); 5874 ts->in_sigsuspend = 0; 5875 5876 /* if the CPU is in VM86 mode, we restore the 32 bit values */ 5877 #if defined(TARGET_I386) && !defined(TARGET_X86_64) 5878 { 5879 CPUX86State *env = cpu_env; 5880 if (env->eflags & VM_MASK) 5881 save_v86_state(env); 5882 } 5883 #endif 5884 /* prepare the stack frame of the virtual CPU */ 5885 #if defined(TARGET_ABI_MIPSN32) || defined(TARGET_ABI_MIPSN64) \ 5886 || defined(TARGET_OPENRISC) || defined(TARGET_TILEGX) 5887 /* These targets do not have traditional signals. */ 5888 setup_rt_frame(sig, sa, &k->info, &target_old_set, cpu_env); 5889 #else 5890 if (sa->sa_flags & TARGET_SA_SIGINFO) 5891 setup_rt_frame(sig, sa, &k->info, &target_old_set, cpu_env); 5892 else 5893 setup_frame(sig, sa, &target_old_set, cpu_env); 5894 #endif 5895 if (sa->sa_flags & TARGET_SA_RESETHAND) { 5896 sa->_sa_handler = TARGET_SIG_DFL; 5897 } 5898 } 5899 } 5900 5901 void process_pending_signals(CPUArchState *cpu_env) 5902 { 5903 CPUState *cpu = ENV_GET_CPU(cpu_env); 5904 int sig; 5905 TaskState *ts = cpu->opaque; 5906 sigset_t set; 5907 sigset_t *blocked_set; 5908 5909 while (atomic_read(&ts->signal_pending)) { 5910 /* FIXME: This is not threadsafe. */ 5911 sigfillset(&set); 5912 sigprocmask(SIG_SETMASK, &set, 0); 5913 5914 sig = ts->sync_signal.pending; 5915 if (sig) { 5916 /* Synchronous signals are forced, 5917 * see force_sig_info() and callers in Linux 5918 * Note that not all of our queue_signal() calls in QEMU correspond 5919 * to force_sig_info() calls in Linux (some are send_sig_info()). 5920 * However it seems like a kernel bug to me to allow the process 5921 * to block a synchronous signal since it could then just end up 5922 * looping round and round indefinitely. 5923 */ 5924 if (sigismember(&ts->signal_mask, target_to_host_signal_table[sig]) 5925 || sigact_table[sig - 1]._sa_handler == TARGET_SIG_IGN) { 5926 sigdelset(&ts->signal_mask, target_to_host_signal_table[sig]); 5927 sigact_table[sig - 1]._sa_handler = TARGET_SIG_DFL; 5928 } 5929 5930 handle_pending_signal(cpu_env, sig); 5931 } 5932 5933 for (sig = 1; sig <= TARGET_NSIG; sig++) { 5934 blocked_set = ts->in_sigsuspend ? 5935 &ts->sigsuspend_mask : &ts->signal_mask; 5936 5937 if (ts->sigtab[sig - 1].pending && 5938 (!sigismember(blocked_set, 5939 target_to_host_signal_table[sig]))) { 5940 handle_pending_signal(cpu_env, sig); 5941 /* Restart scan from the beginning */ 5942 sig = 1; 5943 } 5944 } 5945 5946 /* if no signal is pending, unblock signals and recheck (the act 5947 * of unblocking might cause us to take another host signal which 5948 * will set signal_pending again). 5949 */ 5950 atomic_set(&ts->signal_pending, 0); 5951 ts->in_sigsuspend = 0; 5952 set = ts->signal_mask; 5953 sigdelset(&set, SIGSEGV); 5954 sigdelset(&set, SIGBUS); 5955 sigprocmask(SIG_SETMASK, &set, 0); 5956 } 5957 ts->in_sigsuspend = 0; 5958 } 5959