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