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