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