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