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