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