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