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