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