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_MIPSN64) 2442 2443 # warning signal handling not implemented 2444 2445 static void setup_frame(int sig, struct target_sigaction *ka, 2446 target_sigset_t *set, CPUMIPSState *env) 2447 { 2448 fprintf(stderr, "setup_frame: not implemented\n"); 2449 } 2450 2451 static void setup_rt_frame(int sig, struct target_sigaction *ka, 2452 target_siginfo_t *info, 2453 target_sigset_t *set, CPUMIPSState *env) 2454 { 2455 fprintf(stderr, "setup_rt_frame: not implemented\n"); 2456 } 2457 2458 long do_sigreturn(CPUMIPSState *env) 2459 { 2460 fprintf(stderr, "do_sigreturn: not implemented\n"); 2461 return -TARGET_ENOSYS; 2462 } 2463 2464 long do_rt_sigreturn(CPUMIPSState *env) 2465 { 2466 fprintf(stderr, "do_rt_sigreturn: not implemented\n"); 2467 return -TARGET_ENOSYS; 2468 } 2469 2470 #elif defined(TARGET_ABI_MIPSN32) 2471 2472 # warning signal handling not implemented 2473 2474 static void setup_frame(int sig, struct target_sigaction *ka, 2475 target_sigset_t *set, CPUMIPSState *env) 2476 { 2477 fprintf(stderr, "setup_frame: not implemented\n"); 2478 } 2479 2480 static void setup_rt_frame(int sig, struct target_sigaction *ka, 2481 target_siginfo_t *info, 2482 target_sigset_t *set, CPUMIPSState *env) 2483 { 2484 fprintf(stderr, "setup_rt_frame: not implemented\n"); 2485 } 2486 2487 long do_sigreturn(CPUMIPSState *env) 2488 { 2489 fprintf(stderr, "do_sigreturn: not implemented\n"); 2490 return -TARGET_ENOSYS; 2491 } 2492 2493 long do_rt_sigreturn(CPUMIPSState *env) 2494 { 2495 fprintf(stderr, "do_rt_sigreturn: not implemented\n"); 2496 return -TARGET_ENOSYS; 2497 } 2498 2499 #elif defined(TARGET_ABI_MIPSO32) 2500 2501 struct target_sigcontext { 2502 uint32_t sc_regmask; /* Unused */ 2503 uint32_t sc_status; 2504 uint64_t sc_pc; 2505 uint64_t sc_regs[32]; 2506 uint64_t sc_fpregs[32]; 2507 uint32_t sc_ownedfp; /* Unused */ 2508 uint32_t sc_fpc_csr; 2509 uint32_t sc_fpc_eir; /* Unused */ 2510 uint32_t sc_used_math; 2511 uint32_t sc_dsp; /* dsp status, was sc_ssflags */ 2512 uint32_t pad0; 2513 uint64_t sc_mdhi; 2514 uint64_t sc_mdlo; 2515 target_ulong sc_hi1; /* Was sc_cause */ 2516 target_ulong sc_lo1; /* Was sc_badvaddr */ 2517 target_ulong sc_hi2; /* Was sc_sigset[4] */ 2518 target_ulong sc_lo2; 2519 target_ulong sc_hi3; 2520 target_ulong sc_lo3; 2521 }; 2522 2523 struct sigframe { 2524 uint32_t sf_ass[4]; /* argument save space for o32 */ 2525 uint32_t sf_code[2]; /* signal trampoline */ 2526 struct target_sigcontext sf_sc; 2527 target_sigset_t sf_mask; 2528 }; 2529 2530 struct target_ucontext { 2531 target_ulong tuc_flags; 2532 target_ulong tuc_link; 2533 target_stack_t tuc_stack; 2534 target_ulong pad0; 2535 struct target_sigcontext tuc_mcontext; 2536 target_sigset_t tuc_sigmask; 2537 }; 2538 2539 struct target_rt_sigframe { 2540 uint32_t rs_ass[4]; /* argument save space for o32 */ 2541 uint32_t rs_code[2]; /* signal trampoline */ 2542 struct target_siginfo rs_info; 2543 struct target_ucontext rs_uc; 2544 }; 2545 2546 /* Install trampoline to jump back from signal handler */ 2547 static inline int install_sigtramp(unsigned int *tramp, unsigned int syscall) 2548 { 2549 int err; 2550 2551 /* 2552 * Set up the return code ... 2553 * 2554 * li v0, __NR__foo_sigreturn 2555 * syscall 2556 */ 2557 2558 err = __put_user(0x24020000 + syscall, tramp + 0); 2559 err |= __put_user(0x0000000c , tramp + 1); 2560 /* flush_cache_sigtramp((unsigned long) tramp); */ 2561 return err; 2562 } 2563 2564 static inline int 2565 setup_sigcontext(CPUMIPSState *regs, struct target_sigcontext *sc) 2566 { 2567 int err = 0; 2568 2569 err |= __put_user(regs->active_tc.PC, &sc->sc_pc); 2570 2571 #define save_gp_reg(i) do { \ 2572 err |= __put_user(regs->active_tc.gpr[i], &sc->sc_regs[i]); \ 2573 } while(0) 2574 __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2); 2575 save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6); 2576 save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10); 2577 save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14); 2578 save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18); 2579 save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22); 2580 save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26); 2581 save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30); 2582 save_gp_reg(31); 2583 #undef save_gp_reg 2584 2585 err |= __put_user(regs->active_tc.HI[0], &sc->sc_mdhi); 2586 err |= __put_user(regs->active_tc.LO[0], &sc->sc_mdlo); 2587 2588 /* Not used yet, but might be useful if we ever have DSP suppport */ 2589 #if 0 2590 if (cpu_has_dsp) { 2591 err |= __put_user(mfhi1(), &sc->sc_hi1); 2592 err |= __put_user(mflo1(), &sc->sc_lo1); 2593 err |= __put_user(mfhi2(), &sc->sc_hi2); 2594 err |= __put_user(mflo2(), &sc->sc_lo2); 2595 err |= __put_user(mfhi3(), &sc->sc_hi3); 2596 err |= __put_user(mflo3(), &sc->sc_lo3); 2597 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp); 2598 } 2599 /* same with 64 bit */ 2600 #ifdef CONFIG_64BIT 2601 err |= __put_user(regs->hi, &sc->sc_hi[0]); 2602 err |= __put_user(regs->lo, &sc->sc_lo[0]); 2603 if (cpu_has_dsp) { 2604 err |= __put_user(mfhi1(), &sc->sc_hi[1]); 2605 err |= __put_user(mflo1(), &sc->sc_lo[1]); 2606 err |= __put_user(mfhi2(), &sc->sc_hi[2]); 2607 err |= __put_user(mflo2(), &sc->sc_lo[2]); 2608 err |= __put_user(mfhi3(), &sc->sc_hi[3]); 2609 err |= __put_user(mflo3(), &sc->sc_lo[3]); 2610 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp); 2611 } 2612 #endif 2613 #endif 2614 2615 #if 0 2616 err |= __put_user(!!used_math(), &sc->sc_used_math); 2617 2618 if (!used_math()) 2619 goto out; 2620 2621 /* 2622 * Save FPU state to signal context. Signal handler will "inherit" 2623 * current FPU state. 2624 */ 2625 preempt_disable(); 2626 2627 if (!is_fpu_owner()) { 2628 own_fpu(); 2629 restore_fp(current); 2630 } 2631 err |= save_fp_context(sc); 2632 2633 preempt_enable(); 2634 out: 2635 #endif 2636 return err; 2637 } 2638 2639 static inline int 2640 restore_sigcontext(CPUMIPSState *regs, struct target_sigcontext *sc) 2641 { 2642 int err = 0; 2643 2644 err |= __get_user(regs->CP0_EPC, &sc->sc_pc); 2645 2646 err |= __get_user(regs->active_tc.HI[0], &sc->sc_mdhi); 2647 err |= __get_user(regs->active_tc.LO[0], &sc->sc_mdlo); 2648 2649 #define restore_gp_reg(i) do { \ 2650 err |= __get_user(regs->active_tc.gpr[i], &sc->sc_regs[i]); \ 2651 } while(0) 2652 restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3); 2653 restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6); 2654 restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9); 2655 restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12); 2656 restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15); 2657 restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18); 2658 restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21); 2659 restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24); 2660 restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27); 2661 restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30); 2662 restore_gp_reg(31); 2663 #undef restore_gp_reg 2664 2665 #if 0 2666 if (cpu_has_dsp) { 2667 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg); 2668 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg); 2669 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg); 2670 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg); 2671 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg); 2672 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg); 2673 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK); 2674 } 2675 #ifdef CONFIG_64BIT 2676 err |= __get_user(regs->hi, &sc->sc_hi[0]); 2677 err |= __get_user(regs->lo, &sc->sc_lo[0]); 2678 if (cpu_has_dsp) { 2679 err |= __get_user(treg, &sc->sc_hi[1]); mthi1(treg); 2680 err |= __get_user(treg, &sc->sc_lo[1]); mthi1(treg); 2681 err |= __get_user(treg, &sc->sc_hi[2]); mthi2(treg); 2682 err |= __get_user(treg, &sc->sc_lo[2]); mthi2(treg); 2683 err |= __get_user(treg, &sc->sc_hi[3]); mthi3(treg); 2684 err |= __get_user(treg, &sc->sc_lo[3]); mthi3(treg); 2685 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK); 2686 } 2687 #endif 2688 2689 err |= __get_user(used_math, &sc->sc_used_math); 2690 conditional_used_math(used_math); 2691 2692 preempt_disable(); 2693 2694 if (used_math()) { 2695 /* restore fpu context if we have used it before */ 2696 own_fpu(); 2697 err |= restore_fp_context(sc); 2698 } else { 2699 /* signal handler may have used FPU. Give it up. */ 2700 lose_fpu(); 2701 } 2702 2703 preempt_enable(); 2704 #endif 2705 return err; 2706 } 2707 /* 2708 * Determine which stack to use.. 2709 */ 2710 static inline abi_ulong 2711 get_sigframe(struct target_sigaction *ka, CPUMIPSState *regs, size_t frame_size) 2712 { 2713 unsigned long sp; 2714 2715 /* Default to using normal stack */ 2716 sp = regs->active_tc.gpr[29]; 2717 2718 /* 2719 * FPU emulator may have its own trampoline active just 2720 * above the user stack, 16-bytes before the next lowest 2721 * 16 byte boundary. Try to avoid trashing it. 2722 */ 2723 sp -= 32; 2724 2725 /* This is the X/Open sanctioned signal stack switching. */ 2726 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) { 2727 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 2728 } 2729 2730 return (sp - frame_size) & ~7; 2731 } 2732 2733 /* compare linux/arch/mips/kernel/signal.c:setup_frame() */ 2734 static void setup_frame(int sig, struct target_sigaction * ka, 2735 target_sigset_t *set, CPUMIPSState *regs) 2736 { 2737 struct sigframe *frame; 2738 abi_ulong frame_addr; 2739 int i; 2740 2741 frame_addr = get_sigframe(ka, regs, sizeof(*frame)); 2742 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 2743 goto give_sigsegv; 2744 2745 install_sigtramp(frame->sf_code, TARGET_NR_sigreturn); 2746 2747 if(setup_sigcontext(regs, &frame->sf_sc)) 2748 goto give_sigsegv; 2749 2750 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 2751 if(__put_user(set->sig[i], &frame->sf_mask.sig[i])) 2752 goto give_sigsegv; 2753 } 2754 2755 /* 2756 * Arguments to signal handler: 2757 * 2758 * a0 = signal number 2759 * a1 = 0 (should be cause) 2760 * a2 = pointer to struct sigcontext 2761 * 2762 * $25 and PC point to the signal handler, $29 points to the 2763 * struct sigframe. 2764 */ 2765 regs->active_tc.gpr[ 4] = sig; 2766 regs->active_tc.gpr[ 5] = 0; 2767 regs->active_tc.gpr[ 6] = frame_addr + offsetof(struct sigframe, sf_sc); 2768 regs->active_tc.gpr[29] = frame_addr; 2769 regs->active_tc.gpr[31] = frame_addr + offsetof(struct sigframe, sf_code); 2770 /* The original kernel code sets CP0_EPC to the handler 2771 * since it returns to userland using eret 2772 * we cannot do this here, and we must set PC directly */ 2773 regs->active_tc.PC = regs->active_tc.gpr[25] = ka->_sa_handler; 2774 unlock_user_struct(frame, frame_addr, 1); 2775 return; 2776 2777 give_sigsegv: 2778 unlock_user_struct(frame, frame_addr, 1); 2779 force_sig(TARGET_SIGSEGV/*, current*/); 2780 } 2781 2782 long do_sigreturn(CPUMIPSState *regs) 2783 { 2784 struct sigframe *frame; 2785 abi_ulong frame_addr; 2786 sigset_t blocked; 2787 target_sigset_t target_set; 2788 int i; 2789 2790 #if defined(DEBUG_SIGNAL) 2791 fprintf(stderr, "do_sigreturn\n"); 2792 #endif 2793 frame_addr = regs->active_tc.gpr[29]; 2794 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 2795 goto badframe; 2796 2797 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 2798 if(__get_user(target_set.sig[i], &frame->sf_mask.sig[i])) 2799 goto badframe; 2800 } 2801 2802 target_to_host_sigset_internal(&blocked, &target_set); 2803 sigprocmask(SIG_SETMASK, &blocked, NULL); 2804 2805 if (restore_sigcontext(regs, &frame->sf_sc)) 2806 goto badframe; 2807 2808 #if 0 2809 /* 2810 * Don't let your children do this ... 2811 */ 2812 __asm__ __volatile__( 2813 "move\t$29, %0\n\t" 2814 "j\tsyscall_exit" 2815 :/* no outputs */ 2816 :"r" (®s)); 2817 /* Unreached */ 2818 #endif 2819 2820 regs->active_tc.PC = regs->CP0_EPC; 2821 /* I am not sure this is right, but it seems to work 2822 * maybe a problem with nested signals ? */ 2823 regs->CP0_EPC = 0; 2824 return -TARGET_QEMU_ESIGRETURN; 2825 2826 badframe: 2827 force_sig(TARGET_SIGSEGV/*, current*/); 2828 return 0; 2829 } 2830 2831 static void setup_rt_frame(int sig, struct target_sigaction *ka, 2832 target_siginfo_t *info, 2833 target_sigset_t *set, CPUMIPSState *env) 2834 { 2835 struct target_rt_sigframe *frame; 2836 abi_ulong frame_addr; 2837 int i; 2838 2839 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 2840 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 2841 goto give_sigsegv; 2842 2843 install_sigtramp(frame->rs_code, TARGET_NR_rt_sigreturn); 2844 2845 copy_siginfo_to_user(&frame->rs_info, info); 2846 2847 __put_user(0, &frame->rs_uc.tuc_flags); 2848 __put_user(0, &frame->rs_uc.tuc_link); 2849 __put_user(target_sigaltstack_used.ss_sp, &frame->rs_uc.tuc_stack.ss_sp); 2850 __put_user(target_sigaltstack_used.ss_size, &frame->rs_uc.tuc_stack.ss_size); 2851 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), 2852 &frame->rs_uc.tuc_stack.ss_flags); 2853 2854 setup_sigcontext(env, &frame->rs_uc.tuc_mcontext); 2855 2856 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 2857 __put_user(set->sig[i], &frame->rs_uc.tuc_sigmask.sig[i]); 2858 } 2859 2860 /* 2861 * Arguments to signal handler: 2862 * 2863 * a0 = signal number 2864 * a1 = pointer to siginfo_t 2865 * a2 = pointer to struct ucontext 2866 * 2867 * $25 and PC point to the signal handler, $29 points to the 2868 * struct sigframe. 2869 */ 2870 env->active_tc.gpr[ 4] = sig; 2871 env->active_tc.gpr[ 5] = frame_addr 2872 + offsetof(struct target_rt_sigframe, rs_info); 2873 env->active_tc.gpr[ 6] = frame_addr 2874 + offsetof(struct target_rt_sigframe, rs_uc); 2875 env->active_tc.gpr[29] = frame_addr; 2876 env->active_tc.gpr[31] = frame_addr 2877 + offsetof(struct target_rt_sigframe, rs_code); 2878 /* The original kernel code sets CP0_EPC to the handler 2879 * since it returns to userland using eret 2880 * we cannot do this here, and we must set PC directly */ 2881 env->active_tc.PC = env->active_tc.gpr[25] = ka->_sa_handler; 2882 unlock_user_struct(frame, frame_addr, 1); 2883 return; 2884 2885 give_sigsegv: 2886 unlock_user_struct(frame, frame_addr, 1); 2887 force_sig(TARGET_SIGSEGV/*, current*/); 2888 } 2889 2890 long do_rt_sigreturn(CPUMIPSState *env) 2891 { 2892 struct target_rt_sigframe *frame; 2893 abi_ulong frame_addr; 2894 sigset_t blocked; 2895 2896 #if defined(DEBUG_SIGNAL) 2897 fprintf(stderr, "do_rt_sigreturn\n"); 2898 #endif 2899 frame_addr = env->active_tc.gpr[29]; 2900 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 2901 goto badframe; 2902 2903 target_to_host_sigset(&blocked, &frame->rs_uc.tuc_sigmask); 2904 sigprocmask(SIG_SETMASK, &blocked, NULL); 2905 2906 if (restore_sigcontext(env, &frame->rs_uc.tuc_mcontext)) 2907 goto badframe; 2908 2909 if (do_sigaltstack(frame_addr + 2910 offsetof(struct target_rt_sigframe, rs_uc.tuc_stack), 2911 0, get_sp_from_cpustate(env)) == -EFAULT) 2912 goto badframe; 2913 2914 env->active_tc.PC = env->CP0_EPC; 2915 /* I am not sure this is right, but it seems to work 2916 * maybe a problem with nested signals ? */ 2917 env->CP0_EPC = 0; 2918 return -TARGET_QEMU_ESIGRETURN; 2919 2920 badframe: 2921 force_sig(TARGET_SIGSEGV/*, current*/); 2922 return 0; 2923 } 2924 2925 #elif defined(TARGET_SH4) 2926 2927 /* 2928 * code and data structures from linux kernel: 2929 * include/asm-sh/sigcontext.h 2930 * arch/sh/kernel/signal.c 2931 */ 2932 2933 struct target_sigcontext { 2934 target_ulong oldmask; 2935 2936 /* CPU registers */ 2937 target_ulong sc_gregs[16]; 2938 target_ulong sc_pc; 2939 target_ulong sc_pr; 2940 target_ulong sc_sr; 2941 target_ulong sc_gbr; 2942 target_ulong sc_mach; 2943 target_ulong sc_macl; 2944 2945 /* FPU registers */ 2946 target_ulong sc_fpregs[16]; 2947 target_ulong sc_xfpregs[16]; 2948 unsigned int sc_fpscr; 2949 unsigned int sc_fpul; 2950 unsigned int sc_ownedfp; 2951 }; 2952 2953 struct target_sigframe 2954 { 2955 struct target_sigcontext sc; 2956 target_ulong extramask[TARGET_NSIG_WORDS-1]; 2957 uint16_t retcode[3]; 2958 }; 2959 2960 2961 struct target_ucontext { 2962 target_ulong tuc_flags; 2963 struct target_ucontext *tuc_link; 2964 target_stack_t tuc_stack; 2965 struct target_sigcontext tuc_mcontext; 2966 target_sigset_t tuc_sigmask; /* mask last for extensibility */ 2967 }; 2968 2969 struct target_rt_sigframe 2970 { 2971 struct target_siginfo info; 2972 struct target_ucontext uc; 2973 uint16_t retcode[3]; 2974 }; 2975 2976 2977 #define MOVW(n) (0x9300|((n)-2)) /* Move mem word at PC+n to R3 */ 2978 #define TRAP_NOARG 0xc310 /* Syscall w/no args (NR in R3) SH3/4 */ 2979 2980 static abi_ulong get_sigframe(struct target_sigaction *ka, 2981 unsigned long sp, size_t frame_size) 2982 { 2983 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags(sp) == 0)) { 2984 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 2985 } 2986 2987 return (sp - frame_size) & -8ul; 2988 } 2989 2990 static int setup_sigcontext(struct target_sigcontext *sc, 2991 CPUSH4State *regs, unsigned long mask) 2992 { 2993 int err = 0; 2994 int i; 2995 2996 #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x) 2997 COPY(gregs[0]); COPY(gregs[1]); 2998 COPY(gregs[2]); COPY(gregs[3]); 2999 COPY(gregs[4]); COPY(gregs[5]); 3000 COPY(gregs[6]); COPY(gregs[7]); 3001 COPY(gregs[8]); COPY(gregs[9]); 3002 COPY(gregs[10]); COPY(gregs[11]); 3003 COPY(gregs[12]); COPY(gregs[13]); 3004 COPY(gregs[14]); COPY(gregs[15]); 3005 COPY(gbr); COPY(mach); 3006 COPY(macl); COPY(pr); 3007 COPY(sr); COPY(pc); 3008 #undef COPY 3009 3010 for (i=0; i<16; i++) { 3011 err |= __put_user(regs->fregs[i], &sc->sc_fpregs[i]); 3012 } 3013 err |= __put_user(regs->fpscr, &sc->sc_fpscr); 3014 err |= __put_user(regs->fpul, &sc->sc_fpul); 3015 3016 /* non-iBCS2 extensions.. */ 3017 err |= __put_user(mask, &sc->oldmask); 3018 3019 return err; 3020 } 3021 3022 static int restore_sigcontext(CPUSH4State *regs, struct target_sigcontext *sc, 3023 target_ulong *r0_p) 3024 { 3025 unsigned int err = 0; 3026 int i; 3027 3028 #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x) 3029 COPY(gregs[1]); 3030 COPY(gregs[2]); COPY(gregs[3]); 3031 COPY(gregs[4]); COPY(gregs[5]); 3032 COPY(gregs[6]); COPY(gregs[7]); 3033 COPY(gregs[8]); COPY(gregs[9]); 3034 COPY(gregs[10]); COPY(gregs[11]); 3035 COPY(gregs[12]); COPY(gregs[13]); 3036 COPY(gregs[14]); COPY(gregs[15]); 3037 COPY(gbr); COPY(mach); 3038 COPY(macl); COPY(pr); 3039 COPY(sr); COPY(pc); 3040 #undef COPY 3041 3042 for (i=0; i<16; i++) { 3043 err |= __get_user(regs->fregs[i], &sc->sc_fpregs[i]); 3044 } 3045 err |= __get_user(regs->fpscr, &sc->sc_fpscr); 3046 err |= __get_user(regs->fpul, &sc->sc_fpul); 3047 3048 regs->tra = -1; /* disable syscall checks */ 3049 err |= __get_user(*r0_p, &sc->sc_gregs[0]); 3050 return err; 3051 } 3052 3053 static void setup_frame(int sig, struct target_sigaction *ka, 3054 target_sigset_t *set, CPUSH4State *regs) 3055 { 3056 struct target_sigframe *frame; 3057 abi_ulong frame_addr; 3058 int i; 3059 int err = 0; 3060 int signal; 3061 3062 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame)); 3063 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 3064 goto give_sigsegv; 3065 3066 signal = current_exec_domain_sig(sig); 3067 3068 err |= setup_sigcontext(&frame->sc, regs, set->sig[0]); 3069 3070 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) { 3071 err |= __put_user(set->sig[i + 1], &frame->extramask[i]); 3072 } 3073 3074 /* Set up to return from userspace. If provided, use a stub 3075 already in userspace. */ 3076 if (ka->sa_flags & TARGET_SA_RESTORER) { 3077 regs->pr = (unsigned long) ka->sa_restorer; 3078 } else { 3079 /* Generate return code (system call to sigreturn) */ 3080 err |= __put_user(MOVW(2), &frame->retcode[0]); 3081 err |= __put_user(TRAP_NOARG, &frame->retcode[1]); 3082 err |= __put_user((TARGET_NR_sigreturn), &frame->retcode[2]); 3083 regs->pr = (unsigned long) frame->retcode; 3084 } 3085 3086 if (err) 3087 goto give_sigsegv; 3088 3089 /* Set up registers for signal handler */ 3090 regs->gregs[15] = frame_addr; 3091 regs->gregs[4] = signal; /* Arg for signal handler */ 3092 regs->gregs[5] = 0; 3093 regs->gregs[6] = frame_addr += offsetof(typeof(*frame), sc); 3094 regs->pc = (unsigned long) ka->_sa_handler; 3095 3096 unlock_user_struct(frame, frame_addr, 1); 3097 return; 3098 3099 give_sigsegv: 3100 unlock_user_struct(frame, frame_addr, 1); 3101 force_sig(TARGET_SIGSEGV); 3102 } 3103 3104 static void setup_rt_frame(int sig, struct target_sigaction *ka, 3105 target_siginfo_t *info, 3106 target_sigset_t *set, CPUSH4State *regs) 3107 { 3108 struct target_rt_sigframe *frame; 3109 abi_ulong frame_addr; 3110 int i; 3111 int err = 0; 3112 int signal; 3113 3114 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame)); 3115 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 3116 goto give_sigsegv; 3117 3118 signal = current_exec_domain_sig(sig); 3119 3120 err |= copy_siginfo_to_user(&frame->info, info); 3121 3122 /* Create the ucontext. */ 3123 err |= __put_user(0, &frame->uc.tuc_flags); 3124 err |= __put_user(0, (unsigned long *)&frame->uc.tuc_link); 3125 err |= __put_user((unsigned long)target_sigaltstack_used.ss_sp, 3126 &frame->uc.tuc_stack.ss_sp); 3127 err |= __put_user(sas_ss_flags(regs->gregs[15]), 3128 &frame->uc.tuc_stack.ss_flags); 3129 err |= __put_user(target_sigaltstack_used.ss_size, 3130 &frame->uc.tuc_stack.ss_size); 3131 err |= setup_sigcontext(&frame->uc.tuc_mcontext, 3132 regs, set->sig[0]); 3133 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 3134 err |= __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]); 3135 } 3136 3137 /* Set up to return from userspace. If provided, use a stub 3138 already in userspace. */ 3139 if (ka->sa_flags & TARGET_SA_RESTORER) { 3140 regs->pr = (unsigned long) ka->sa_restorer; 3141 } else { 3142 /* Generate return code (system call to sigreturn) */ 3143 err |= __put_user(MOVW(2), &frame->retcode[0]); 3144 err |= __put_user(TRAP_NOARG, &frame->retcode[1]); 3145 err |= __put_user((TARGET_NR_rt_sigreturn), &frame->retcode[2]); 3146 regs->pr = (unsigned long) frame->retcode; 3147 } 3148 3149 if (err) 3150 goto give_sigsegv; 3151 3152 /* Set up registers for signal handler */ 3153 regs->gregs[15] = frame_addr; 3154 regs->gregs[4] = signal; /* Arg for signal handler */ 3155 regs->gregs[5] = frame_addr + offsetof(typeof(*frame), info); 3156 regs->gregs[6] = frame_addr + offsetof(typeof(*frame), uc); 3157 regs->pc = (unsigned long) ka->_sa_handler; 3158 3159 unlock_user_struct(frame, frame_addr, 1); 3160 return; 3161 3162 give_sigsegv: 3163 unlock_user_struct(frame, frame_addr, 1); 3164 force_sig(TARGET_SIGSEGV); 3165 } 3166 3167 long do_sigreturn(CPUSH4State *regs) 3168 { 3169 struct target_sigframe *frame; 3170 abi_ulong frame_addr; 3171 sigset_t blocked; 3172 target_sigset_t target_set; 3173 target_ulong r0; 3174 int i; 3175 int err = 0; 3176 3177 #if defined(DEBUG_SIGNAL) 3178 fprintf(stderr, "do_sigreturn\n"); 3179 #endif 3180 frame_addr = regs->gregs[15]; 3181 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 3182 goto badframe; 3183 3184 err |= __get_user(target_set.sig[0], &frame->sc.oldmask); 3185 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 3186 err |= (__get_user(target_set.sig[i], &frame->extramask[i - 1])); 3187 } 3188 3189 if (err) 3190 goto badframe; 3191 3192 target_to_host_sigset_internal(&blocked, &target_set); 3193 sigprocmask(SIG_SETMASK, &blocked, NULL); 3194 3195 if (restore_sigcontext(regs, &frame->sc, &r0)) 3196 goto badframe; 3197 3198 unlock_user_struct(frame, frame_addr, 0); 3199 return r0; 3200 3201 badframe: 3202 unlock_user_struct(frame, frame_addr, 0); 3203 force_sig(TARGET_SIGSEGV); 3204 return 0; 3205 } 3206 3207 long do_rt_sigreturn(CPUSH4State *regs) 3208 { 3209 struct target_rt_sigframe *frame; 3210 abi_ulong frame_addr; 3211 sigset_t blocked; 3212 target_ulong r0; 3213 3214 #if defined(DEBUG_SIGNAL) 3215 fprintf(stderr, "do_rt_sigreturn\n"); 3216 #endif 3217 frame_addr = regs->gregs[15]; 3218 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 3219 goto badframe; 3220 3221 target_to_host_sigset(&blocked, &frame->uc.tuc_sigmask); 3222 sigprocmask(SIG_SETMASK, &blocked, NULL); 3223 3224 if (restore_sigcontext(regs, &frame->uc.tuc_mcontext, &r0)) 3225 goto badframe; 3226 3227 if (do_sigaltstack(frame_addr + 3228 offsetof(struct target_rt_sigframe, uc.tuc_stack), 3229 0, get_sp_from_cpustate(regs)) == -EFAULT) 3230 goto badframe; 3231 3232 unlock_user_struct(frame, frame_addr, 0); 3233 return r0; 3234 3235 badframe: 3236 unlock_user_struct(frame, frame_addr, 0); 3237 force_sig(TARGET_SIGSEGV); 3238 return 0; 3239 } 3240 #elif defined(TARGET_MICROBLAZE) 3241 3242 struct target_sigcontext { 3243 struct target_pt_regs regs; /* needs to be first */ 3244 uint32_t oldmask; 3245 }; 3246 3247 struct target_stack_t { 3248 abi_ulong ss_sp; 3249 int ss_flags; 3250 unsigned int ss_size; 3251 }; 3252 3253 struct target_ucontext { 3254 abi_ulong tuc_flags; 3255 abi_ulong tuc_link; 3256 struct target_stack_t tuc_stack; 3257 struct target_sigcontext tuc_mcontext; 3258 uint32_t tuc_extramask[TARGET_NSIG_WORDS - 1]; 3259 }; 3260 3261 /* Signal frames. */ 3262 struct target_signal_frame { 3263 struct target_ucontext uc; 3264 uint32_t extramask[TARGET_NSIG_WORDS - 1]; 3265 uint32_t tramp[2]; 3266 }; 3267 3268 struct rt_signal_frame { 3269 siginfo_t info; 3270 struct ucontext uc; 3271 uint32_t tramp[2]; 3272 }; 3273 3274 static void setup_sigcontext(struct target_sigcontext *sc, CPUMBState *env) 3275 { 3276 __put_user(env->regs[0], &sc->regs.r0); 3277 __put_user(env->regs[1], &sc->regs.r1); 3278 __put_user(env->regs[2], &sc->regs.r2); 3279 __put_user(env->regs[3], &sc->regs.r3); 3280 __put_user(env->regs[4], &sc->regs.r4); 3281 __put_user(env->regs[5], &sc->regs.r5); 3282 __put_user(env->regs[6], &sc->regs.r6); 3283 __put_user(env->regs[7], &sc->regs.r7); 3284 __put_user(env->regs[8], &sc->regs.r8); 3285 __put_user(env->regs[9], &sc->regs.r9); 3286 __put_user(env->regs[10], &sc->regs.r10); 3287 __put_user(env->regs[11], &sc->regs.r11); 3288 __put_user(env->regs[12], &sc->regs.r12); 3289 __put_user(env->regs[13], &sc->regs.r13); 3290 __put_user(env->regs[14], &sc->regs.r14); 3291 __put_user(env->regs[15], &sc->regs.r15); 3292 __put_user(env->regs[16], &sc->regs.r16); 3293 __put_user(env->regs[17], &sc->regs.r17); 3294 __put_user(env->regs[18], &sc->regs.r18); 3295 __put_user(env->regs[19], &sc->regs.r19); 3296 __put_user(env->regs[20], &sc->regs.r20); 3297 __put_user(env->regs[21], &sc->regs.r21); 3298 __put_user(env->regs[22], &sc->regs.r22); 3299 __put_user(env->regs[23], &sc->regs.r23); 3300 __put_user(env->regs[24], &sc->regs.r24); 3301 __put_user(env->regs[25], &sc->regs.r25); 3302 __put_user(env->regs[26], &sc->regs.r26); 3303 __put_user(env->regs[27], &sc->regs.r27); 3304 __put_user(env->regs[28], &sc->regs.r28); 3305 __put_user(env->regs[29], &sc->regs.r29); 3306 __put_user(env->regs[30], &sc->regs.r30); 3307 __put_user(env->regs[31], &sc->regs.r31); 3308 __put_user(env->sregs[SR_PC], &sc->regs.pc); 3309 } 3310 3311 static void restore_sigcontext(struct target_sigcontext *sc, CPUMBState *env) 3312 { 3313 __get_user(env->regs[0], &sc->regs.r0); 3314 __get_user(env->regs[1], &sc->regs.r1); 3315 __get_user(env->regs[2], &sc->regs.r2); 3316 __get_user(env->regs[3], &sc->regs.r3); 3317 __get_user(env->regs[4], &sc->regs.r4); 3318 __get_user(env->regs[5], &sc->regs.r5); 3319 __get_user(env->regs[6], &sc->regs.r6); 3320 __get_user(env->regs[7], &sc->regs.r7); 3321 __get_user(env->regs[8], &sc->regs.r8); 3322 __get_user(env->regs[9], &sc->regs.r9); 3323 __get_user(env->regs[10], &sc->regs.r10); 3324 __get_user(env->regs[11], &sc->regs.r11); 3325 __get_user(env->regs[12], &sc->regs.r12); 3326 __get_user(env->regs[13], &sc->regs.r13); 3327 __get_user(env->regs[14], &sc->regs.r14); 3328 __get_user(env->regs[15], &sc->regs.r15); 3329 __get_user(env->regs[16], &sc->regs.r16); 3330 __get_user(env->regs[17], &sc->regs.r17); 3331 __get_user(env->regs[18], &sc->regs.r18); 3332 __get_user(env->regs[19], &sc->regs.r19); 3333 __get_user(env->regs[20], &sc->regs.r20); 3334 __get_user(env->regs[21], &sc->regs.r21); 3335 __get_user(env->regs[22], &sc->regs.r22); 3336 __get_user(env->regs[23], &sc->regs.r23); 3337 __get_user(env->regs[24], &sc->regs.r24); 3338 __get_user(env->regs[25], &sc->regs.r25); 3339 __get_user(env->regs[26], &sc->regs.r26); 3340 __get_user(env->regs[27], &sc->regs.r27); 3341 __get_user(env->regs[28], &sc->regs.r28); 3342 __get_user(env->regs[29], &sc->regs.r29); 3343 __get_user(env->regs[30], &sc->regs.r30); 3344 __get_user(env->regs[31], &sc->regs.r31); 3345 __get_user(env->sregs[SR_PC], &sc->regs.pc); 3346 } 3347 3348 static abi_ulong get_sigframe(struct target_sigaction *ka, 3349 CPUMBState *env, int frame_size) 3350 { 3351 abi_ulong sp = env->regs[1]; 3352 3353 if ((ka->sa_flags & SA_ONSTACK) != 0 && !on_sig_stack(sp)) 3354 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 3355 3356 return ((sp - frame_size) & -8UL); 3357 } 3358 3359 static void setup_frame(int sig, struct target_sigaction *ka, 3360 target_sigset_t *set, CPUMBState *env) 3361 { 3362 struct target_signal_frame *frame; 3363 abi_ulong frame_addr; 3364 int err = 0; 3365 int i; 3366 3367 frame_addr = get_sigframe(ka, env, sizeof *frame); 3368 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 3369 goto badframe; 3370 3371 /* Save the mask. */ 3372 err |= __put_user(set->sig[0], &frame->uc.tuc_mcontext.oldmask); 3373 if (err) 3374 goto badframe; 3375 3376 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 3377 if (__put_user(set->sig[i], &frame->extramask[i - 1])) 3378 goto badframe; 3379 } 3380 3381 setup_sigcontext(&frame->uc.tuc_mcontext, env); 3382 3383 /* Set up to return from userspace. If provided, use a stub 3384 already in userspace. */ 3385 /* minus 8 is offset to cater for "rtsd r15,8" offset */ 3386 if (ka->sa_flags & TARGET_SA_RESTORER) { 3387 env->regs[15] = ((unsigned long)ka->sa_restorer)-8; 3388 } else { 3389 uint32_t t; 3390 /* Note, these encodings are _big endian_! */ 3391 /* addi r12, r0, __NR_sigreturn */ 3392 t = 0x31800000UL | TARGET_NR_sigreturn; 3393 err |= __put_user(t, frame->tramp + 0); 3394 /* brki r14, 0x8 */ 3395 t = 0xb9cc0008UL; 3396 err |= __put_user(t, frame->tramp + 1); 3397 3398 /* Return from sighandler will jump to the tramp. 3399 Negative 8 offset because return is rtsd r15, 8 */ 3400 env->regs[15] = ((unsigned long)frame->tramp) - 8; 3401 } 3402 3403 if (err) 3404 goto badframe; 3405 3406 /* Set up registers for signal handler */ 3407 env->regs[1] = frame_addr; 3408 /* Signal handler args: */ 3409 env->regs[5] = sig; /* Arg 0: signum */ 3410 env->regs[6] = 0; 3411 /* arg 1: sigcontext */ 3412 env->regs[7] = frame_addr += offsetof(typeof(*frame), uc); 3413 3414 /* Offset of 4 to handle microblaze rtid r14, 0 */ 3415 env->sregs[SR_PC] = (unsigned long)ka->_sa_handler; 3416 3417 unlock_user_struct(frame, frame_addr, 1); 3418 return; 3419 badframe: 3420 unlock_user_struct(frame, frame_addr, 1); 3421 force_sig(TARGET_SIGSEGV); 3422 } 3423 3424 static void setup_rt_frame(int sig, struct target_sigaction *ka, 3425 target_siginfo_t *info, 3426 target_sigset_t *set, CPUMBState *env) 3427 { 3428 fprintf(stderr, "Microblaze setup_rt_frame: not implemented\n"); 3429 } 3430 3431 long do_sigreturn(CPUMBState *env) 3432 { 3433 struct target_signal_frame *frame; 3434 abi_ulong frame_addr; 3435 target_sigset_t target_set; 3436 sigset_t set; 3437 int i; 3438 3439 frame_addr = env->regs[R_SP]; 3440 /* Make sure the guest isn't playing games. */ 3441 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1)) 3442 goto badframe; 3443 3444 /* Restore blocked signals */ 3445 if (__get_user(target_set.sig[0], &frame->uc.tuc_mcontext.oldmask)) 3446 goto badframe; 3447 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 3448 if (__get_user(target_set.sig[i], &frame->extramask[i - 1])) 3449 goto badframe; 3450 } 3451 target_to_host_sigset_internal(&set, &target_set); 3452 sigprocmask(SIG_SETMASK, &set, NULL); 3453 3454 restore_sigcontext(&frame->uc.tuc_mcontext, env); 3455 /* We got here through a sigreturn syscall, our path back is via an 3456 rtb insn so setup r14 for that. */ 3457 env->regs[14] = env->sregs[SR_PC]; 3458 3459 unlock_user_struct(frame, frame_addr, 0); 3460 return env->regs[10]; 3461 badframe: 3462 unlock_user_struct(frame, frame_addr, 0); 3463 force_sig(TARGET_SIGSEGV); 3464 } 3465 3466 long do_rt_sigreturn(CPUMBState *env) 3467 { 3468 fprintf(stderr, "Microblaze do_rt_sigreturn: not implemented\n"); 3469 return -TARGET_ENOSYS; 3470 } 3471 3472 #elif defined(TARGET_CRIS) 3473 3474 struct target_sigcontext { 3475 struct target_pt_regs regs; /* needs to be first */ 3476 uint32_t oldmask; 3477 uint32_t usp; /* usp before stacking this gunk on it */ 3478 }; 3479 3480 /* Signal frames. */ 3481 struct target_signal_frame { 3482 struct target_sigcontext sc; 3483 uint32_t extramask[TARGET_NSIG_WORDS - 1]; 3484 uint8_t retcode[8]; /* Trampoline code. */ 3485 }; 3486 3487 struct rt_signal_frame { 3488 siginfo_t *pinfo; 3489 void *puc; 3490 siginfo_t info; 3491 struct ucontext uc; 3492 uint8_t retcode[8]; /* Trampoline code. */ 3493 }; 3494 3495 static void setup_sigcontext(struct target_sigcontext *sc, CPUCRISState *env) 3496 { 3497 __put_user(env->regs[0], &sc->regs.r0); 3498 __put_user(env->regs[1], &sc->regs.r1); 3499 __put_user(env->regs[2], &sc->regs.r2); 3500 __put_user(env->regs[3], &sc->regs.r3); 3501 __put_user(env->regs[4], &sc->regs.r4); 3502 __put_user(env->regs[5], &sc->regs.r5); 3503 __put_user(env->regs[6], &sc->regs.r6); 3504 __put_user(env->regs[7], &sc->regs.r7); 3505 __put_user(env->regs[8], &sc->regs.r8); 3506 __put_user(env->regs[9], &sc->regs.r9); 3507 __put_user(env->regs[10], &sc->regs.r10); 3508 __put_user(env->regs[11], &sc->regs.r11); 3509 __put_user(env->regs[12], &sc->regs.r12); 3510 __put_user(env->regs[13], &sc->regs.r13); 3511 __put_user(env->regs[14], &sc->usp); 3512 __put_user(env->regs[15], &sc->regs.acr); 3513 __put_user(env->pregs[PR_MOF], &sc->regs.mof); 3514 __put_user(env->pregs[PR_SRP], &sc->regs.srp); 3515 __put_user(env->pc, &sc->regs.erp); 3516 } 3517 3518 static void restore_sigcontext(struct target_sigcontext *sc, CPUCRISState *env) 3519 { 3520 __get_user(env->regs[0], &sc->regs.r0); 3521 __get_user(env->regs[1], &sc->regs.r1); 3522 __get_user(env->regs[2], &sc->regs.r2); 3523 __get_user(env->regs[3], &sc->regs.r3); 3524 __get_user(env->regs[4], &sc->regs.r4); 3525 __get_user(env->regs[5], &sc->regs.r5); 3526 __get_user(env->regs[6], &sc->regs.r6); 3527 __get_user(env->regs[7], &sc->regs.r7); 3528 __get_user(env->regs[8], &sc->regs.r8); 3529 __get_user(env->regs[9], &sc->regs.r9); 3530 __get_user(env->regs[10], &sc->regs.r10); 3531 __get_user(env->regs[11], &sc->regs.r11); 3532 __get_user(env->regs[12], &sc->regs.r12); 3533 __get_user(env->regs[13], &sc->regs.r13); 3534 __get_user(env->regs[14], &sc->usp); 3535 __get_user(env->regs[15], &sc->regs.acr); 3536 __get_user(env->pregs[PR_MOF], &sc->regs.mof); 3537 __get_user(env->pregs[PR_SRP], &sc->regs.srp); 3538 __get_user(env->pc, &sc->regs.erp); 3539 } 3540 3541 static abi_ulong get_sigframe(CPUCRISState *env, int framesize) 3542 { 3543 abi_ulong sp; 3544 /* Align the stack downwards to 4. */ 3545 sp = (env->regs[R_SP] & ~3); 3546 return sp - framesize; 3547 } 3548 3549 static void setup_frame(int sig, struct target_sigaction *ka, 3550 target_sigset_t *set, CPUCRISState *env) 3551 { 3552 struct target_signal_frame *frame; 3553 abi_ulong frame_addr; 3554 int err = 0; 3555 int i; 3556 3557 frame_addr = get_sigframe(env, sizeof *frame); 3558 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 3559 goto badframe; 3560 3561 /* 3562 * The CRIS signal return trampoline. A real linux/CRIS kernel doesn't 3563 * use this trampoline anymore but it sets it up for GDB. 3564 * In QEMU, using the trampoline simplifies things a bit so we use it. 3565 * 3566 * This is movu.w __NR_sigreturn, r9; break 13; 3567 */ 3568 err |= __put_user(0x9c5f, frame->retcode+0); 3569 err |= __put_user(TARGET_NR_sigreturn, 3570 frame->retcode+2); 3571 err |= __put_user(0xe93d, frame->retcode+4); 3572 3573 /* Save the mask. */ 3574 err |= __put_user(set->sig[0], &frame->sc.oldmask); 3575 if (err) 3576 goto badframe; 3577 3578 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 3579 if (__put_user(set->sig[i], &frame->extramask[i - 1])) 3580 goto badframe; 3581 } 3582 3583 setup_sigcontext(&frame->sc, env); 3584 3585 /* Move the stack and setup the arguments for the handler. */ 3586 env->regs[R_SP] = frame_addr; 3587 env->regs[10] = sig; 3588 env->pc = (unsigned long) ka->_sa_handler; 3589 /* Link SRP so the guest returns through the trampoline. */ 3590 env->pregs[PR_SRP] = frame_addr + offsetof(typeof(*frame), retcode); 3591 3592 unlock_user_struct(frame, frame_addr, 1); 3593 return; 3594 badframe: 3595 unlock_user_struct(frame, frame_addr, 1); 3596 force_sig(TARGET_SIGSEGV); 3597 } 3598 3599 static void setup_rt_frame(int sig, struct target_sigaction *ka, 3600 target_siginfo_t *info, 3601 target_sigset_t *set, CPUCRISState *env) 3602 { 3603 fprintf(stderr, "CRIS setup_rt_frame: not implemented\n"); 3604 } 3605 3606 long do_sigreturn(CPUCRISState *env) 3607 { 3608 struct target_signal_frame *frame; 3609 abi_ulong frame_addr; 3610 target_sigset_t target_set; 3611 sigset_t set; 3612 int i; 3613 3614 frame_addr = env->regs[R_SP]; 3615 /* Make sure the guest isn't playing games. */ 3616 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1)) 3617 goto badframe; 3618 3619 /* Restore blocked signals */ 3620 if (__get_user(target_set.sig[0], &frame->sc.oldmask)) 3621 goto badframe; 3622 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 3623 if (__get_user(target_set.sig[i], &frame->extramask[i - 1])) 3624 goto badframe; 3625 } 3626 target_to_host_sigset_internal(&set, &target_set); 3627 sigprocmask(SIG_SETMASK, &set, NULL); 3628 3629 restore_sigcontext(&frame->sc, env); 3630 unlock_user_struct(frame, frame_addr, 0); 3631 return env->regs[10]; 3632 badframe: 3633 unlock_user_struct(frame, frame_addr, 0); 3634 force_sig(TARGET_SIGSEGV); 3635 } 3636 3637 long do_rt_sigreturn(CPUCRISState *env) 3638 { 3639 fprintf(stderr, "CRIS do_rt_sigreturn: not implemented\n"); 3640 return -TARGET_ENOSYS; 3641 } 3642 3643 #elif defined(TARGET_OPENRISC) 3644 3645 struct target_sigcontext { 3646 struct target_pt_regs regs; 3647 abi_ulong oldmask; 3648 abi_ulong usp; 3649 }; 3650 3651 struct target_ucontext { 3652 abi_ulong tuc_flags; 3653 abi_ulong tuc_link; 3654 target_stack_t tuc_stack; 3655 struct target_sigcontext tuc_mcontext; 3656 target_sigset_t tuc_sigmask; /* mask last for extensibility */ 3657 }; 3658 3659 struct target_rt_sigframe { 3660 abi_ulong pinfo; 3661 uint64_t puc; 3662 struct target_siginfo info; 3663 struct target_sigcontext sc; 3664 struct target_ucontext uc; 3665 unsigned char retcode[16]; /* trampoline code */ 3666 }; 3667 3668 /* This is the asm-generic/ucontext.h version */ 3669 #if 0 3670 static int restore_sigcontext(CPUOpenRISCState *regs, 3671 struct target_sigcontext *sc) 3672 { 3673 unsigned int err = 0; 3674 unsigned long old_usp; 3675 3676 /* Alwys make any pending restarted system call return -EINTR */ 3677 current_thread_info()->restart_block.fn = do_no_restart_syscall; 3678 3679 /* restore the regs from &sc->regs (same as sc, since regs is first) 3680 * (sc is already checked for VERIFY_READ since the sigframe was 3681 * checked in sys_sigreturn previously) 3682 */ 3683 3684 if (copy_from_user(regs, &sc, sizeof(struct target_pt_regs))) { 3685 goto badframe; 3686 } 3687 3688 /* make sure the U-flag is set so user-mode cannot fool us */ 3689 3690 regs->sr &= ~SR_SM; 3691 3692 /* restore the old USP as it was before we stacked the sc etc. 3693 * (we cannot just pop the sigcontext since we aligned the sp and 3694 * stuff after pushing it) 3695 */ 3696 3697 err |= __get_user(old_usp, &sc->usp); 3698 phx_signal("old_usp 0x%lx", old_usp); 3699 3700 __PHX__ REALLY /* ??? */ 3701 wrusp(old_usp); 3702 regs->gpr[1] = old_usp; 3703 3704 /* TODO: the other ports use regs->orig_XX to disable syscall checks 3705 * after this completes, but we don't use that mechanism. maybe we can 3706 * use it now ? 3707 */ 3708 3709 return err; 3710 3711 badframe: 3712 return 1; 3713 } 3714 #endif 3715 3716 /* Set up a signal frame. */ 3717 3718 static int setup_sigcontext(struct target_sigcontext *sc, 3719 CPUOpenRISCState *regs, 3720 unsigned long mask) 3721 { 3722 int err = 0; 3723 unsigned long usp = regs->gpr[1]; 3724 3725 /* copy the regs. they are first in sc so we can use sc directly */ 3726 3727 /*err |= copy_to_user(&sc, regs, sizeof(struct target_pt_regs));*/ 3728 3729 /* Set the frametype to CRIS_FRAME_NORMAL for the execution of 3730 the signal handler. The frametype will be restored to its previous 3731 value in restore_sigcontext. */ 3732 /*regs->frametype = CRIS_FRAME_NORMAL;*/ 3733 3734 /* then some other stuff */ 3735 err |= __put_user(mask, &sc->oldmask); 3736 err |= __put_user(usp, &sc->usp); return err; 3737 } 3738 3739 static inline unsigned long align_sigframe(unsigned long sp) 3740 { 3741 unsigned long i; 3742 i = sp & ~3UL; 3743 return i; 3744 } 3745 3746 static inline abi_ulong get_sigframe(struct target_sigaction *ka, 3747 CPUOpenRISCState *regs, 3748 size_t frame_size) 3749 { 3750 unsigned long sp = regs->gpr[1]; 3751 int onsigstack = on_sig_stack(sp); 3752 3753 /* redzone */ 3754 /* This is the X/Open sanctioned signal stack switching. */ 3755 if ((ka->sa_flags & SA_ONSTACK) != 0 && !onsigstack) { 3756 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 3757 } 3758 3759 sp = align_sigframe(sp - frame_size); 3760 3761 /* 3762 * If we are on the alternate signal stack and would overflow it, don't. 3763 * Return an always-bogus address instead so we will die with SIGSEGV. 3764 */ 3765 3766 if (onsigstack && !likely(on_sig_stack(sp))) { 3767 return -1L; 3768 } 3769 3770 return sp; 3771 } 3772 3773 static void setup_frame(int sig, struct target_sigaction *ka, 3774 target_sigset_t *set, CPUOpenRISCState *env) 3775 { 3776 qemu_log("Not implement.\n"); 3777 } 3778 3779 static void setup_rt_frame(int sig, struct target_sigaction *ka, 3780 target_siginfo_t *info, 3781 target_sigset_t *set, CPUOpenRISCState *env) 3782 { 3783 int err = 0; 3784 abi_ulong frame_addr; 3785 unsigned long return_ip; 3786 struct target_rt_sigframe *frame; 3787 abi_ulong info_addr, uc_addr; 3788 3789 frame_addr = get_sigframe(ka, env, sizeof *frame); 3790 3791 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 3792 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 3793 goto give_sigsegv; 3794 } 3795 3796 info_addr = frame_addr + offsetof(struct target_rt_sigframe, info); 3797 err |= __put_user(info_addr, &frame->pinfo); 3798 uc_addr = frame_addr + offsetof(struct target_rt_sigframe, uc); 3799 err |= __put_user(uc_addr, &frame->puc); 3800 3801 if (ka->sa_flags & SA_SIGINFO) { 3802 err |= copy_siginfo_to_user(&frame->info, info); 3803 } 3804 if (err) { 3805 goto give_sigsegv; 3806 } 3807 3808 /*err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext));*/ 3809 err |= __put_user(0, &frame->uc.tuc_flags); 3810 err |= __put_user(0, &frame->uc.tuc_link); 3811 err |= __put_user(target_sigaltstack_used.ss_sp, 3812 &frame->uc.tuc_stack.ss_sp); 3813 err |= __put_user(sas_ss_flags(env->gpr[1]), &frame->uc.tuc_stack.ss_flags); 3814 err |= __put_user(target_sigaltstack_used.ss_size, 3815 &frame->uc.tuc_stack.ss_size); 3816 err |= setup_sigcontext(&frame->sc, env, set->sig[0]); 3817 3818 /*err |= copy_to_user(frame->uc.tuc_sigmask, set, sizeof(*set));*/ 3819 3820 if (err) { 3821 goto give_sigsegv; 3822 } 3823 3824 /* trampoline - the desired return ip is the retcode itself */ 3825 return_ip = (unsigned long)&frame->retcode; 3826 /* This is l.ori r11,r0,__NR_sigreturn, l.sys 1 */ 3827 err |= __put_user(0xa960, (short *)(frame->retcode + 0)); 3828 err |= __put_user(TARGET_NR_rt_sigreturn, (short *)(frame->retcode + 2)); 3829 err |= __put_user(0x20000001, (unsigned long *)(frame->retcode + 4)); 3830 err |= __put_user(0x15000000, (unsigned long *)(frame->retcode + 8)); 3831 3832 if (err) { 3833 goto give_sigsegv; 3834 } 3835 3836 /* TODO what is the current->exec_domain stuff and invmap ? */ 3837 3838 /* Set up registers for signal handler */ 3839 env->pc = (unsigned long)ka->_sa_handler; /* what we enter NOW */ 3840 env->gpr[9] = (unsigned long)return_ip; /* what we enter LATER */ 3841 env->gpr[3] = (unsigned long)sig; /* arg 1: signo */ 3842 env->gpr[4] = (unsigned long)&frame->info; /* arg 2: (siginfo_t*) */ 3843 env->gpr[5] = (unsigned long)&frame->uc; /* arg 3: ucontext */ 3844 3845 /* actually move the usp to reflect the stacked frame */ 3846 env->gpr[1] = (unsigned long)frame; 3847 3848 return; 3849 3850 give_sigsegv: 3851 unlock_user_struct(frame, frame_addr, 1); 3852 if (sig == TARGET_SIGSEGV) { 3853 ka->_sa_handler = TARGET_SIG_DFL; 3854 } 3855 force_sig(TARGET_SIGSEGV); 3856 } 3857 3858 long do_sigreturn(CPUOpenRISCState *env) 3859 { 3860 3861 qemu_log("do_sigreturn: not implemented\n"); 3862 return -TARGET_ENOSYS; 3863 } 3864 3865 long do_rt_sigreturn(CPUOpenRISCState *env) 3866 { 3867 qemu_log("do_rt_sigreturn: not implemented\n"); 3868 return -TARGET_ENOSYS; 3869 } 3870 /* TARGET_OPENRISC */ 3871 3872 #elif defined(TARGET_S390X) 3873 3874 #define __NUM_GPRS 16 3875 #define __NUM_FPRS 16 3876 #define __NUM_ACRS 16 3877 3878 #define S390_SYSCALL_SIZE 2 3879 #define __SIGNAL_FRAMESIZE 160 /* FIXME: 31-bit mode -> 96 */ 3880 3881 #define _SIGCONTEXT_NSIG 64 3882 #define _SIGCONTEXT_NSIG_BPW 64 /* FIXME: 31-bit mode -> 32 */ 3883 #define _SIGCONTEXT_NSIG_WORDS (_SIGCONTEXT_NSIG / _SIGCONTEXT_NSIG_BPW) 3884 #define _SIGMASK_COPY_SIZE (sizeof(unsigned long)*_SIGCONTEXT_NSIG_WORDS) 3885 #define PSW_ADDR_AMODE 0x0000000000000000UL /* 0x80000000UL for 31-bit */ 3886 #define S390_SYSCALL_OPCODE ((uint16_t)0x0a00) 3887 3888 typedef struct { 3889 target_psw_t psw; 3890 target_ulong gprs[__NUM_GPRS]; 3891 unsigned int acrs[__NUM_ACRS]; 3892 } target_s390_regs_common; 3893 3894 typedef struct { 3895 unsigned int fpc; 3896 double fprs[__NUM_FPRS]; 3897 } target_s390_fp_regs; 3898 3899 typedef struct { 3900 target_s390_regs_common regs; 3901 target_s390_fp_regs fpregs; 3902 } target_sigregs; 3903 3904 struct target_sigcontext { 3905 target_ulong oldmask[_SIGCONTEXT_NSIG_WORDS]; 3906 target_sigregs *sregs; 3907 }; 3908 3909 typedef struct { 3910 uint8_t callee_used_stack[__SIGNAL_FRAMESIZE]; 3911 struct target_sigcontext sc; 3912 target_sigregs sregs; 3913 int signo; 3914 uint8_t retcode[S390_SYSCALL_SIZE]; 3915 } sigframe; 3916 3917 struct target_ucontext { 3918 target_ulong tuc_flags; 3919 struct target_ucontext *tuc_link; 3920 target_stack_t tuc_stack; 3921 target_sigregs tuc_mcontext; 3922 target_sigset_t tuc_sigmask; /* mask last for extensibility */ 3923 }; 3924 3925 typedef struct { 3926 uint8_t callee_used_stack[__SIGNAL_FRAMESIZE]; 3927 uint8_t retcode[S390_SYSCALL_SIZE]; 3928 struct target_siginfo info; 3929 struct target_ucontext uc; 3930 } rt_sigframe; 3931 3932 static inline abi_ulong 3933 get_sigframe(struct target_sigaction *ka, CPUS390XState *env, size_t frame_size) 3934 { 3935 abi_ulong sp; 3936 3937 /* Default to using normal stack */ 3938 sp = env->regs[15]; 3939 3940 /* This is the X/Open sanctioned signal stack switching. */ 3941 if (ka->sa_flags & TARGET_SA_ONSTACK) { 3942 if (!sas_ss_flags(sp)) { 3943 sp = target_sigaltstack_used.ss_sp + 3944 target_sigaltstack_used.ss_size; 3945 } 3946 } 3947 3948 /* This is the legacy signal stack switching. */ 3949 else if (/* FIXME !user_mode(regs) */ 0 && 3950 !(ka->sa_flags & TARGET_SA_RESTORER) && 3951 ka->sa_restorer) { 3952 sp = (abi_ulong) ka->sa_restorer; 3953 } 3954 3955 return (sp - frame_size) & -8ul; 3956 } 3957 3958 static void save_sigregs(CPUS390XState *env, target_sigregs *sregs) 3959 { 3960 int i; 3961 //save_access_regs(current->thread.acrs); FIXME 3962 3963 /* Copy a 'clean' PSW mask to the user to avoid leaking 3964 information about whether PER is currently on. */ 3965 __put_user(env->psw.mask, &sregs->regs.psw.mask); 3966 __put_user(env->psw.addr, &sregs->regs.psw.addr); 3967 for (i = 0; i < 16; i++) { 3968 __put_user(env->regs[i], &sregs->regs.gprs[i]); 3969 } 3970 for (i = 0; i < 16; i++) { 3971 __put_user(env->aregs[i], &sregs->regs.acrs[i]); 3972 } 3973 /* 3974 * We have to store the fp registers to current->thread.fp_regs 3975 * to merge them with the emulated registers. 3976 */ 3977 //save_fp_regs(¤t->thread.fp_regs); FIXME 3978 for (i = 0; i < 16; i++) { 3979 __put_user(env->fregs[i].ll, &sregs->fpregs.fprs[i]); 3980 } 3981 } 3982 3983 static void setup_frame(int sig, struct target_sigaction *ka, 3984 target_sigset_t *set, CPUS390XState *env) 3985 { 3986 sigframe *frame; 3987 abi_ulong frame_addr; 3988 3989 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 3990 qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__, 3991 (unsigned long long)frame_addr); 3992 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 3993 goto give_sigsegv; 3994 } 3995 3996 qemu_log("%s: 1\n", __FUNCTION__); 3997 if (__put_user(set->sig[0], &frame->sc.oldmask[0])) { 3998 goto give_sigsegv; 3999 } 4000 4001 save_sigregs(env, &frame->sregs); 4002 4003 __put_user((abi_ulong)(unsigned long)&frame->sregs, 4004 (abi_ulong *)&frame->sc.sregs); 4005 4006 /* Set up to return from userspace. If provided, use a stub 4007 already in userspace. */ 4008 if (ka->sa_flags & TARGET_SA_RESTORER) { 4009 env->regs[14] = (unsigned long) 4010 ka->sa_restorer | PSW_ADDR_AMODE; 4011 } else { 4012 env->regs[14] = (unsigned long) 4013 frame->retcode | PSW_ADDR_AMODE; 4014 if (__put_user(S390_SYSCALL_OPCODE | TARGET_NR_sigreturn, 4015 (uint16_t *)(frame->retcode))) 4016 goto give_sigsegv; 4017 } 4018 4019 /* Set up backchain. */ 4020 if (__put_user(env->regs[15], (abi_ulong *) frame)) { 4021 goto give_sigsegv; 4022 } 4023 4024 /* Set up registers for signal handler */ 4025 env->regs[15] = frame_addr; 4026 env->psw.addr = (target_ulong) ka->_sa_handler | PSW_ADDR_AMODE; 4027 4028 env->regs[2] = sig; //map_signal(sig); 4029 env->regs[3] = frame_addr += offsetof(typeof(*frame), sc); 4030 4031 /* We forgot to include these in the sigcontext. 4032 To avoid breaking binary compatibility, they are passed as args. */ 4033 env->regs[4] = 0; // FIXME: no clue... current->thread.trap_no; 4034 env->regs[5] = 0; // FIXME: no clue... current->thread.prot_addr; 4035 4036 /* Place signal number on stack to allow backtrace from handler. */ 4037 if (__put_user(env->regs[2], (int *) &frame->signo)) { 4038 goto give_sigsegv; 4039 } 4040 unlock_user_struct(frame, frame_addr, 1); 4041 return; 4042 4043 give_sigsegv: 4044 qemu_log("%s: give_sigsegv\n", __FUNCTION__); 4045 unlock_user_struct(frame, frame_addr, 1); 4046 force_sig(TARGET_SIGSEGV); 4047 } 4048 4049 static void setup_rt_frame(int sig, struct target_sigaction *ka, 4050 target_siginfo_t *info, 4051 target_sigset_t *set, CPUS390XState *env) 4052 { 4053 int i; 4054 rt_sigframe *frame; 4055 abi_ulong frame_addr; 4056 4057 frame_addr = get_sigframe(ka, env, sizeof *frame); 4058 qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__, 4059 (unsigned long long)frame_addr); 4060 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 4061 goto give_sigsegv; 4062 } 4063 4064 qemu_log("%s: 1\n", __FUNCTION__); 4065 if (copy_siginfo_to_user(&frame->info, info)) { 4066 goto give_sigsegv; 4067 } 4068 4069 /* Create the ucontext. */ 4070 __put_user(0, &frame->uc.tuc_flags); 4071 __put_user((abi_ulong)0, (abi_ulong *)&frame->uc.tuc_link); 4072 __put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp); 4073 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), 4074 &frame->uc.tuc_stack.ss_flags); 4075 __put_user(target_sigaltstack_used.ss_size, &frame->uc.tuc_stack.ss_size); 4076 save_sigregs(env, &frame->uc.tuc_mcontext); 4077 for (i = 0; i < TARGET_NSIG_WORDS; i++) { 4078 __put_user((abi_ulong)set->sig[i], 4079 (abi_ulong *)&frame->uc.tuc_sigmask.sig[i]); 4080 } 4081 4082 /* Set up to return from userspace. If provided, use a stub 4083 already in userspace. */ 4084 if (ka->sa_flags & TARGET_SA_RESTORER) { 4085 env->regs[14] = (unsigned long) ka->sa_restorer | PSW_ADDR_AMODE; 4086 } else { 4087 env->regs[14] = (unsigned long) frame->retcode | PSW_ADDR_AMODE; 4088 if (__put_user(S390_SYSCALL_OPCODE | TARGET_NR_rt_sigreturn, 4089 (uint16_t *)(frame->retcode))) { 4090 goto give_sigsegv; 4091 } 4092 } 4093 4094 /* Set up backchain. */ 4095 if (__put_user(env->regs[15], (abi_ulong *) frame)) { 4096 goto give_sigsegv; 4097 } 4098 4099 /* Set up registers for signal handler */ 4100 env->regs[15] = frame_addr; 4101 env->psw.addr = (target_ulong) ka->_sa_handler | PSW_ADDR_AMODE; 4102 4103 env->regs[2] = sig; //map_signal(sig); 4104 env->regs[3] = frame_addr + offsetof(typeof(*frame), info); 4105 env->regs[4] = frame_addr + offsetof(typeof(*frame), uc); 4106 return; 4107 4108 give_sigsegv: 4109 qemu_log("%s: give_sigsegv\n", __FUNCTION__); 4110 unlock_user_struct(frame, frame_addr, 1); 4111 force_sig(TARGET_SIGSEGV); 4112 } 4113 4114 static int 4115 restore_sigregs(CPUS390XState *env, target_sigregs *sc) 4116 { 4117 int err = 0; 4118 int i; 4119 4120 for (i = 0; i < 16; i++) { 4121 err |= __get_user(env->regs[i], &sc->regs.gprs[i]); 4122 } 4123 4124 err |= __get_user(env->psw.mask, &sc->regs.psw.mask); 4125 qemu_log("%s: sc->regs.psw.addr 0x%llx env->psw.addr 0x%llx\n", 4126 __FUNCTION__, (unsigned long long)sc->regs.psw.addr, 4127 (unsigned long long)env->psw.addr); 4128 err |= __get_user(env->psw.addr, &sc->regs.psw.addr); 4129 /* FIXME: 31-bit -> | PSW_ADDR_AMODE */ 4130 4131 for (i = 0; i < 16; i++) { 4132 err |= __get_user(env->aregs[i], &sc->regs.acrs[i]); 4133 } 4134 for (i = 0; i < 16; i++) { 4135 err |= __get_user(env->fregs[i].ll, &sc->fpregs.fprs[i]); 4136 } 4137 4138 return err; 4139 } 4140 4141 long do_sigreturn(CPUS390XState *env) 4142 { 4143 sigframe *frame; 4144 abi_ulong frame_addr = env->regs[15]; 4145 qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__, 4146 (unsigned long long)frame_addr); 4147 target_sigset_t target_set; 4148 sigset_t set; 4149 4150 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) { 4151 goto badframe; 4152 } 4153 if (__get_user(target_set.sig[0], &frame->sc.oldmask[0])) { 4154 goto badframe; 4155 } 4156 4157 target_to_host_sigset_internal(&set, &target_set); 4158 sigprocmask(SIG_SETMASK, &set, NULL); /* ~_BLOCKABLE? */ 4159 4160 if (restore_sigregs(env, &frame->sregs)) { 4161 goto badframe; 4162 } 4163 4164 unlock_user_struct(frame, frame_addr, 0); 4165 return env->regs[2]; 4166 4167 badframe: 4168 unlock_user_struct(frame, frame_addr, 0); 4169 force_sig(TARGET_SIGSEGV); 4170 return 0; 4171 } 4172 4173 long do_rt_sigreturn(CPUS390XState *env) 4174 { 4175 rt_sigframe *frame; 4176 abi_ulong frame_addr = env->regs[15]; 4177 qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__, 4178 (unsigned long long)frame_addr); 4179 sigset_t set; 4180 4181 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) { 4182 goto badframe; 4183 } 4184 target_to_host_sigset(&set, &frame->uc.tuc_sigmask); 4185 4186 sigprocmask(SIG_SETMASK, &set, NULL); /* ~_BLOCKABLE? */ 4187 4188 if (restore_sigregs(env, &frame->uc.tuc_mcontext)) { 4189 goto badframe; 4190 } 4191 4192 if (do_sigaltstack(frame_addr + offsetof(rt_sigframe, uc.tuc_stack), 0, 4193 get_sp_from_cpustate(env)) == -EFAULT) { 4194 goto badframe; 4195 } 4196 unlock_user_struct(frame, frame_addr, 0); 4197 return env->regs[2]; 4198 4199 badframe: 4200 unlock_user_struct(frame, frame_addr, 0); 4201 force_sig(TARGET_SIGSEGV); 4202 return 0; 4203 } 4204 4205 #elif defined(TARGET_PPC) && !defined(TARGET_PPC64) 4206 4207 /* FIXME: Many of the structures are defined for both PPC and PPC64, but 4208 the signal handling is different enough that we haven't implemented 4209 support for PPC64 yet. Hence the restriction above. 4210 4211 There are various #if'd blocks for code for TARGET_PPC64. These 4212 blocks should go away so that we can successfully run 32-bit and 4213 64-bit binaries on a QEMU configured for PPC64. */ 4214 4215 /* Size of dummy stack frame allocated when calling signal handler. 4216 See arch/powerpc/include/asm/ptrace.h. */ 4217 #if defined(TARGET_PPC64) 4218 #define SIGNAL_FRAMESIZE 128 4219 #else 4220 #define SIGNAL_FRAMESIZE 64 4221 #endif 4222 4223 /* See arch/powerpc/include/asm/sigcontext.h. */ 4224 struct target_sigcontext { 4225 target_ulong _unused[4]; 4226 int32_t signal; 4227 #if defined(TARGET_PPC64) 4228 int32_t pad0; 4229 #endif 4230 target_ulong handler; 4231 target_ulong oldmask; 4232 target_ulong regs; /* struct pt_regs __user * */ 4233 /* TODO: PPC64 includes extra bits here. */ 4234 }; 4235 4236 /* Indices for target_mcontext.mc_gregs, below. 4237 See arch/powerpc/include/asm/ptrace.h for details. */ 4238 enum { 4239 TARGET_PT_R0 = 0, 4240 TARGET_PT_R1 = 1, 4241 TARGET_PT_R2 = 2, 4242 TARGET_PT_R3 = 3, 4243 TARGET_PT_R4 = 4, 4244 TARGET_PT_R5 = 5, 4245 TARGET_PT_R6 = 6, 4246 TARGET_PT_R7 = 7, 4247 TARGET_PT_R8 = 8, 4248 TARGET_PT_R9 = 9, 4249 TARGET_PT_R10 = 10, 4250 TARGET_PT_R11 = 11, 4251 TARGET_PT_R12 = 12, 4252 TARGET_PT_R13 = 13, 4253 TARGET_PT_R14 = 14, 4254 TARGET_PT_R15 = 15, 4255 TARGET_PT_R16 = 16, 4256 TARGET_PT_R17 = 17, 4257 TARGET_PT_R18 = 18, 4258 TARGET_PT_R19 = 19, 4259 TARGET_PT_R20 = 20, 4260 TARGET_PT_R21 = 21, 4261 TARGET_PT_R22 = 22, 4262 TARGET_PT_R23 = 23, 4263 TARGET_PT_R24 = 24, 4264 TARGET_PT_R25 = 25, 4265 TARGET_PT_R26 = 26, 4266 TARGET_PT_R27 = 27, 4267 TARGET_PT_R28 = 28, 4268 TARGET_PT_R29 = 29, 4269 TARGET_PT_R30 = 30, 4270 TARGET_PT_R31 = 31, 4271 TARGET_PT_NIP = 32, 4272 TARGET_PT_MSR = 33, 4273 TARGET_PT_ORIG_R3 = 34, 4274 TARGET_PT_CTR = 35, 4275 TARGET_PT_LNK = 36, 4276 TARGET_PT_XER = 37, 4277 TARGET_PT_CCR = 38, 4278 /* Yes, there are two registers with #39. One is 64-bit only. */ 4279 TARGET_PT_MQ = 39, 4280 TARGET_PT_SOFTE = 39, 4281 TARGET_PT_TRAP = 40, 4282 TARGET_PT_DAR = 41, 4283 TARGET_PT_DSISR = 42, 4284 TARGET_PT_RESULT = 43, 4285 TARGET_PT_REGS_COUNT = 44 4286 }; 4287 4288 /* See arch/powerpc/include/asm/ucontext.h. Only used for 32-bit PPC; 4289 on 64-bit PPC, sigcontext and mcontext are one and the same. */ 4290 struct target_mcontext { 4291 target_ulong mc_gregs[48]; 4292 /* Includes fpscr. */ 4293 uint64_t mc_fregs[33]; 4294 target_ulong mc_pad[2]; 4295 /* We need to handle Altivec and SPE at the same time, which no 4296 kernel needs to do. Fortunately, the kernel defines this bit to 4297 be Altivec-register-large all the time, rather than trying to 4298 twiddle it based on the specific platform. */ 4299 union { 4300 /* SPE vector registers. One extra for SPEFSCR. */ 4301 uint32_t spe[33]; 4302 /* Altivec vector registers. The packing of VSCR and VRSAVE 4303 varies depending on whether we're PPC64 or not: PPC64 splits 4304 them apart; PPC32 stuffs them together. */ 4305 #if defined(TARGET_PPC64) 4306 #define QEMU_NVRREG 34 4307 #else 4308 #define QEMU_NVRREG 33 4309 #endif 4310 ppc_avr_t altivec[QEMU_NVRREG]; 4311 #undef QEMU_NVRREG 4312 } mc_vregs __attribute__((__aligned__(16))); 4313 }; 4314 4315 struct target_ucontext { 4316 target_ulong tuc_flags; 4317 target_ulong tuc_link; /* struct ucontext __user * */ 4318 struct target_sigaltstack tuc_stack; 4319 #if !defined(TARGET_PPC64) 4320 int32_t tuc_pad[7]; 4321 target_ulong tuc_regs; /* struct mcontext __user * 4322 points to uc_mcontext field */ 4323 #endif 4324 target_sigset_t tuc_sigmask; 4325 #if defined(TARGET_PPC64) 4326 target_sigset_t unused[15]; /* Allow for uc_sigmask growth */ 4327 struct target_sigcontext tuc_mcontext; 4328 #else 4329 int32_t tuc_maskext[30]; 4330 int32_t tuc_pad2[3]; 4331 struct target_mcontext tuc_mcontext; 4332 #endif 4333 }; 4334 4335 /* See arch/powerpc/kernel/signal_32.c. */ 4336 struct target_sigframe { 4337 struct target_sigcontext sctx; 4338 struct target_mcontext mctx; 4339 int32_t abigap[56]; 4340 }; 4341 4342 struct target_rt_sigframe { 4343 struct target_siginfo info; 4344 struct target_ucontext uc; 4345 int32_t abigap[56]; 4346 }; 4347 4348 /* We use the mc_pad field for the signal return trampoline. */ 4349 #define tramp mc_pad 4350 4351 /* See arch/powerpc/kernel/signal.c. */ 4352 static target_ulong get_sigframe(struct target_sigaction *ka, 4353 CPUPPCState *env, 4354 int frame_size) 4355 { 4356 target_ulong oldsp, newsp; 4357 4358 oldsp = env->gpr[1]; 4359 4360 if ((ka->sa_flags & TARGET_SA_ONSTACK) && 4361 (sas_ss_flags(oldsp) == 0)) { 4362 oldsp = (target_sigaltstack_used.ss_sp 4363 + target_sigaltstack_used.ss_size); 4364 } 4365 4366 newsp = (oldsp - frame_size) & ~0xFUL; 4367 4368 return newsp; 4369 } 4370 4371 static int save_user_regs(CPUPPCState *env, struct target_mcontext *frame, 4372 int sigret) 4373 { 4374 target_ulong msr = env->msr; 4375 int i; 4376 target_ulong ccr = 0; 4377 4378 /* In general, the kernel attempts to be intelligent about what it 4379 needs to save for Altivec/FP/SPE registers. We don't care that 4380 much, so we just go ahead and save everything. */ 4381 4382 /* Save general registers. */ 4383 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) { 4384 if (__put_user(env->gpr[i], &frame->mc_gregs[i])) { 4385 return 1; 4386 } 4387 } 4388 if (__put_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP]) 4389 || __put_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR]) 4390 || __put_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK]) 4391 || __put_user(env->xer, &frame->mc_gregs[TARGET_PT_XER])) 4392 return 1; 4393 4394 for (i = 0; i < ARRAY_SIZE(env->crf); i++) { 4395 ccr |= env->crf[i] << (32 - ((i + 1) * 4)); 4396 } 4397 if (__put_user(ccr, &frame->mc_gregs[TARGET_PT_CCR])) 4398 return 1; 4399 4400 /* Save Altivec registers if necessary. */ 4401 if (env->insns_flags & PPC_ALTIVEC) { 4402 for (i = 0; i < ARRAY_SIZE(env->avr); i++) { 4403 ppc_avr_t *avr = &env->avr[i]; 4404 ppc_avr_t *vreg = &frame->mc_vregs.altivec[i]; 4405 4406 if (__put_user(avr->u64[0], &vreg->u64[0]) || 4407 __put_user(avr->u64[1], &vreg->u64[1])) { 4408 return 1; 4409 } 4410 } 4411 /* Set MSR_VR in the saved MSR value to indicate that 4412 frame->mc_vregs contains valid data. */ 4413 msr |= MSR_VR; 4414 if (__put_user((uint32_t)env->spr[SPR_VRSAVE], 4415 &frame->mc_vregs.altivec[32].u32[3])) 4416 return 1; 4417 } 4418 4419 /* Save floating point registers. */ 4420 if (env->insns_flags & PPC_FLOAT) { 4421 for (i = 0; i < ARRAY_SIZE(env->fpr); i++) { 4422 if (__put_user(env->fpr[i], &frame->mc_fregs[i])) { 4423 return 1; 4424 } 4425 } 4426 if (__put_user((uint64_t) env->fpscr, &frame->mc_fregs[32])) 4427 return 1; 4428 } 4429 4430 /* Save SPE registers. The kernel only saves the high half. */ 4431 if (env->insns_flags & PPC_SPE) { 4432 #if defined(TARGET_PPC64) 4433 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) { 4434 if (__put_user(env->gpr[i] >> 32, &frame->mc_vregs.spe[i])) { 4435 return 1; 4436 } 4437 } 4438 #else 4439 for (i = 0; i < ARRAY_SIZE(env->gprh); i++) { 4440 if (__put_user(env->gprh[i], &frame->mc_vregs.spe[i])) { 4441 return 1; 4442 } 4443 } 4444 #endif 4445 /* Set MSR_SPE in the saved MSR value to indicate that 4446 frame->mc_vregs contains valid data. */ 4447 msr |= MSR_SPE; 4448 if (__put_user(env->spe_fscr, &frame->mc_vregs.spe[32])) 4449 return 1; 4450 } 4451 4452 /* Store MSR. */ 4453 if (__put_user(msr, &frame->mc_gregs[TARGET_PT_MSR])) 4454 return 1; 4455 4456 /* Set up the sigreturn trampoline: li r0,sigret; sc. */ 4457 if (sigret) { 4458 if (__put_user(0x38000000UL | sigret, &frame->tramp[0]) || 4459 __put_user(0x44000002UL, &frame->tramp[1])) { 4460 return 1; 4461 } 4462 } 4463 4464 return 0; 4465 } 4466 4467 static int restore_user_regs(CPUPPCState *env, 4468 struct target_mcontext *frame, int sig) 4469 { 4470 target_ulong save_r2 = 0; 4471 target_ulong msr; 4472 target_ulong ccr; 4473 4474 int i; 4475 4476 if (!sig) { 4477 save_r2 = env->gpr[2]; 4478 } 4479 4480 /* Restore general registers. */ 4481 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) { 4482 if (__get_user(env->gpr[i], &frame->mc_gregs[i])) { 4483 return 1; 4484 } 4485 } 4486 if (__get_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP]) 4487 || __get_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR]) 4488 || __get_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK]) 4489 || __get_user(env->xer, &frame->mc_gregs[TARGET_PT_XER])) 4490 return 1; 4491 if (__get_user(ccr, &frame->mc_gregs[TARGET_PT_CCR])) 4492 return 1; 4493 4494 for (i = 0; i < ARRAY_SIZE(env->crf); i++) { 4495 env->crf[i] = (ccr >> (32 - ((i + 1) * 4))) & 0xf; 4496 } 4497 4498 if (!sig) { 4499 env->gpr[2] = save_r2; 4500 } 4501 /* Restore MSR. */ 4502 if (__get_user(msr, &frame->mc_gregs[TARGET_PT_MSR])) 4503 return 1; 4504 4505 /* If doing signal return, restore the previous little-endian mode. */ 4506 if (sig) 4507 env->msr = (env->msr & ~MSR_LE) | (msr & MSR_LE); 4508 4509 /* Restore Altivec registers if necessary. */ 4510 if (env->insns_flags & PPC_ALTIVEC) { 4511 for (i = 0; i < ARRAY_SIZE(env->avr); i++) { 4512 ppc_avr_t *avr = &env->avr[i]; 4513 ppc_avr_t *vreg = &frame->mc_vregs.altivec[i]; 4514 4515 if (__get_user(avr->u64[0], &vreg->u64[0]) || 4516 __get_user(avr->u64[1], &vreg->u64[1])) { 4517 return 1; 4518 } 4519 } 4520 /* Set MSR_VEC in the saved MSR value to indicate that 4521 frame->mc_vregs contains valid data. */ 4522 if (__get_user(env->spr[SPR_VRSAVE], 4523 (target_ulong *)(&frame->mc_vregs.altivec[32].u32[3]))) 4524 return 1; 4525 } 4526 4527 /* Restore floating point registers. */ 4528 if (env->insns_flags & PPC_FLOAT) { 4529 uint64_t fpscr; 4530 for (i = 0; i < ARRAY_SIZE(env->fpr); i++) { 4531 if (__get_user(env->fpr[i], &frame->mc_fregs[i])) { 4532 return 1; 4533 } 4534 } 4535 if (__get_user(fpscr, &frame->mc_fregs[32])) 4536 return 1; 4537 env->fpscr = (uint32_t) fpscr; 4538 } 4539 4540 /* Save SPE registers. The kernel only saves the high half. */ 4541 if (env->insns_flags & PPC_SPE) { 4542 #if defined(TARGET_PPC64) 4543 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) { 4544 uint32_t hi; 4545 4546 if (__get_user(hi, &frame->mc_vregs.spe[i])) { 4547 return 1; 4548 } 4549 env->gpr[i] = ((uint64_t)hi << 32) | ((uint32_t) env->gpr[i]); 4550 } 4551 #else 4552 for (i = 0; i < ARRAY_SIZE(env->gprh); i++) { 4553 if (__get_user(env->gprh[i], &frame->mc_vregs.spe[i])) { 4554 return 1; 4555 } 4556 } 4557 #endif 4558 if (__get_user(env->spe_fscr, &frame->mc_vregs.spe[32])) 4559 return 1; 4560 } 4561 4562 return 0; 4563 } 4564 4565 static void setup_frame(int sig, struct target_sigaction *ka, 4566 target_sigset_t *set, CPUPPCState *env) 4567 { 4568 struct target_sigframe *frame; 4569 struct target_sigcontext *sc; 4570 target_ulong frame_addr, newsp; 4571 int err = 0; 4572 int signal; 4573 4574 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 4575 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1)) 4576 goto sigsegv; 4577 sc = &frame->sctx; 4578 4579 signal = current_exec_domain_sig(sig); 4580 4581 err |= __put_user(ka->_sa_handler, &sc->handler); 4582 err |= __put_user(set->sig[0], &sc->oldmask); 4583 #if defined(TARGET_PPC64) 4584 err |= __put_user(set->sig[0] >> 32, &sc->_unused[3]); 4585 #else 4586 err |= __put_user(set->sig[1], &sc->_unused[3]); 4587 #endif 4588 err |= __put_user(h2g(&frame->mctx), &sc->regs); 4589 err |= __put_user(sig, &sc->signal); 4590 4591 /* Save user regs. */ 4592 err |= save_user_regs(env, &frame->mctx, TARGET_NR_sigreturn); 4593 4594 /* The kernel checks for the presence of a VDSO here. We don't 4595 emulate a vdso, so use a sigreturn system call. */ 4596 env->lr = (target_ulong) h2g(frame->mctx.tramp); 4597 4598 /* Turn off all fp exceptions. */ 4599 env->fpscr = 0; 4600 4601 /* Create a stack frame for the caller of the handler. */ 4602 newsp = frame_addr - SIGNAL_FRAMESIZE; 4603 err |= put_user(env->gpr[1], newsp, target_ulong); 4604 4605 if (err) 4606 goto sigsegv; 4607 4608 /* Set up registers for signal handler. */ 4609 env->gpr[1] = newsp; 4610 env->gpr[3] = signal; 4611 env->gpr[4] = frame_addr + offsetof(struct target_sigframe, sctx); 4612 env->nip = (target_ulong) ka->_sa_handler; 4613 /* Signal handlers are entered in big-endian mode. */ 4614 env->msr &= ~MSR_LE; 4615 4616 unlock_user_struct(frame, frame_addr, 1); 4617 return; 4618 4619 sigsegv: 4620 unlock_user_struct(frame, frame_addr, 1); 4621 qemu_log("segfaulting from setup_frame\n"); 4622 force_sig(TARGET_SIGSEGV); 4623 } 4624 4625 static void setup_rt_frame(int sig, struct target_sigaction *ka, 4626 target_siginfo_t *info, 4627 target_sigset_t *set, CPUPPCState *env) 4628 { 4629 struct target_rt_sigframe *rt_sf; 4630 struct target_mcontext *frame; 4631 target_ulong rt_sf_addr, newsp = 0; 4632 int i, err = 0; 4633 int signal; 4634 4635 rt_sf_addr = get_sigframe(ka, env, sizeof(*rt_sf)); 4636 if (!lock_user_struct(VERIFY_WRITE, rt_sf, rt_sf_addr, 1)) 4637 goto sigsegv; 4638 4639 signal = current_exec_domain_sig(sig); 4640 4641 err |= copy_siginfo_to_user(&rt_sf->info, info); 4642 4643 err |= __put_user(0, &rt_sf->uc.tuc_flags); 4644 err |= __put_user(0, &rt_sf->uc.tuc_link); 4645 err |= __put_user((target_ulong)target_sigaltstack_used.ss_sp, 4646 &rt_sf->uc.tuc_stack.ss_sp); 4647 err |= __put_user(sas_ss_flags(env->gpr[1]), 4648 &rt_sf->uc.tuc_stack.ss_flags); 4649 err |= __put_user(target_sigaltstack_used.ss_size, 4650 &rt_sf->uc.tuc_stack.ss_size); 4651 err |= __put_user(h2g (&rt_sf->uc.tuc_mcontext), 4652 &rt_sf->uc.tuc_regs); 4653 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 4654 err |= __put_user(set->sig[i], &rt_sf->uc.tuc_sigmask.sig[i]); 4655 } 4656 4657 frame = &rt_sf->uc.tuc_mcontext; 4658 err |= save_user_regs(env, frame, TARGET_NR_rt_sigreturn); 4659 4660 /* The kernel checks for the presence of a VDSO here. We don't 4661 emulate a vdso, so use a sigreturn system call. */ 4662 env->lr = (target_ulong) h2g(frame->tramp); 4663 4664 /* Turn off all fp exceptions. */ 4665 env->fpscr = 0; 4666 4667 /* Create a stack frame for the caller of the handler. */ 4668 newsp = rt_sf_addr - (SIGNAL_FRAMESIZE + 16); 4669 err |= __put_user(env->gpr[1], (target_ulong *)(uintptr_t) newsp); 4670 4671 if (err) 4672 goto sigsegv; 4673 4674 /* Set up registers for signal handler. */ 4675 env->gpr[1] = newsp; 4676 env->gpr[3] = (target_ulong) signal; 4677 env->gpr[4] = (target_ulong) h2g(&rt_sf->info); 4678 env->gpr[5] = (target_ulong) h2g(&rt_sf->uc); 4679 env->gpr[6] = (target_ulong) h2g(rt_sf); 4680 env->nip = (target_ulong) ka->_sa_handler; 4681 /* Signal handlers are entered in big-endian mode. */ 4682 env->msr &= ~MSR_LE; 4683 4684 unlock_user_struct(rt_sf, rt_sf_addr, 1); 4685 return; 4686 4687 sigsegv: 4688 unlock_user_struct(rt_sf, rt_sf_addr, 1); 4689 qemu_log("segfaulting from setup_rt_frame\n"); 4690 force_sig(TARGET_SIGSEGV); 4691 4692 } 4693 4694 long do_sigreturn(CPUPPCState *env) 4695 { 4696 struct target_sigcontext *sc = NULL; 4697 struct target_mcontext *sr = NULL; 4698 target_ulong sr_addr, sc_addr; 4699 sigset_t blocked; 4700 target_sigset_t set; 4701 4702 sc_addr = env->gpr[1] + SIGNAL_FRAMESIZE; 4703 if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1)) 4704 goto sigsegv; 4705 4706 #if defined(TARGET_PPC64) 4707 set.sig[0] = sc->oldmask + ((long)(sc->_unused[3]) << 32); 4708 #else 4709 if(__get_user(set.sig[0], &sc->oldmask) || 4710 __get_user(set.sig[1], &sc->_unused[3])) 4711 goto sigsegv; 4712 #endif 4713 target_to_host_sigset_internal(&blocked, &set); 4714 sigprocmask(SIG_SETMASK, &blocked, NULL); 4715 4716 if (__get_user(sr_addr, &sc->regs)) 4717 goto sigsegv; 4718 if (!lock_user_struct(VERIFY_READ, sr, sr_addr, 1)) 4719 goto sigsegv; 4720 if (restore_user_regs(env, sr, 1)) 4721 goto sigsegv; 4722 4723 unlock_user_struct(sr, sr_addr, 1); 4724 unlock_user_struct(sc, sc_addr, 1); 4725 return -TARGET_QEMU_ESIGRETURN; 4726 4727 sigsegv: 4728 unlock_user_struct(sr, sr_addr, 1); 4729 unlock_user_struct(sc, sc_addr, 1); 4730 qemu_log("segfaulting from do_sigreturn\n"); 4731 force_sig(TARGET_SIGSEGV); 4732 return 0; 4733 } 4734 4735 /* See arch/powerpc/kernel/signal_32.c. */ 4736 static int do_setcontext(struct target_ucontext *ucp, CPUPPCState *env, int sig) 4737 { 4738 struct target_mcontext *mcp; 4739 target_ulong mcp_addr; 4740 sigset_t blocked; 4741 target_sigset_t set; 4742 4743 if (copy_from_user(&set, h2g(ucp) + offsetof(struct target_ucontext, tuc_sigmask), 4744 sizeof (set))) 4745 return 1; 4746 4747 #if defined(TARGET_PPC64) 4748 fprintf (stderr, "do_setcontext: not implemented\n"); 4749 return 0; 4750 #else 4751 if (__get_user(mcp_addr, &ucp->tuc_regs)) 4752 return 1; 4753 4754 if (!lock_user_struct(VERIFY_READ, mcp, mcp_addr, 1)) 4755 return 1; 4756 4757 target_to_host_sigset_internal(&blocked, &set); 4758 sigprocmask(SIG_SETMASK, &blocked, NULL); 4759 if (restore_user_regs(env, mcp, sig)) 4760 goto sigsegv; 4761 4762 unlock_user_struct(mcp, mcp_addr, 1); 4763 return 0; 4764 4765 sigsegv: 4766 unlock_user_struct(mcp, mcp_addr, 1); 4767 return 1; 4768 #endif 4769 } 4770 4771 long do_rt_sigreturn(CPUPPCState *env) 4772 { 4773 struct target_rt_sigframe *rt_sf = NULL; 4774 target_ulong rt_sf_addr; 4775 4776 rt_sf_addr = env->gpr[1] + SIGNAL_FRAMESIZE + 16; 4777 if (!lock_user_struct(VERIFY_READ, rt_sf, rt_sf_addr, 1)) 4778 goto sigsegv; 4779 4780 if (do_setcontext(&rt_sf->uc, env, 1)) 4781 goto sigsegv; 4782 4783 do_sigaltstack(rt_sf_addr 4784 + offsetof(struct target_rt_sigframe, uc.tuc_stack), 4785 0, env->gpr[1]); 4786 4787 unlock_user_struct(rt_sf, rt_sf_addr, 1); 4788 return -TARGET_QEMU_ESIGRETURN; 4789 4790 sigsegv: 4791 unlock_user_struct(rt_sf, rt_sf_addr, 1); 4792 qemu_log("segfaulting from do_rt_sigreturn\n"); 4793 force_sig(TARGET_SIGSEGV); 4794 return 0; 4795 } 4796 4797 #elif defined(TARGET_M68K) 4798 4799 struct target_sigcontext { 4800 abi_ulong sc_mask; 4801 abi_ulong sc_usp; 4802 abi_ulong sc_d0; 4803 abi_ulong sc_d1; 4804 abi_ulong sc_a0; 4805 abi_ulong sc_a1; 4806 unsigned short sc_sr; 4807 abi_ulong sc_pc; 4808 }; 4809 4810 struct target_sigframe 4811 { 4812 abi_ulong pretcode; 4813 int sig; 4814 int code; 4815 abi_ulong psc; 4816 char retcode[8]; 4817 abi_ulong extramask[TARGET_NSIG_WORDS-1]; 4818 struct target_sigcontext sc; 4819 }; 4820 4821 typedef int target_greg_t; 4822 #define TARGET_NGREG 18 4823 typedef target_greg_t target_gregset_t[TARGET_NGREG]; 4824 4825 typedef struct target_fpregset { 4826 int f_fpcntl[3]; 4827 int f_fpregs[8*3]; 4828 } target_fpregset_t; 4829 4830 struct target_mcontext { 4831 int version; 4832 target_gregset_t gregs; 4833 target_fpregset_t fpregs; 4834 }; 4835 4836 #define TARGET_MCONTEXT_VERSION 2 4837 4838 struct target_ucontext { 4839 abi_ulong tuc_flags; 4840 abi_ulong tuc_link; 4841 target_stack_t tuc_stack; 4842 struct target_mcontext tuc_mcontext; 4843 abi_long tuc_filler[80]; 4844 target_sigset_t tuc_sigmask; 4845 }; 4846 4847 struct target_rt_sigframe 4848 { 4849 abi_ulong pretcode; 4850 int sig; 4851 abi_ulong pinfo; 4852 abi_ulong puc; 4853 char retcode[8]; 4854 struct target_siginfo info; 4855 struct target_ucontext uc; 4856 }; 4857 4858 static int 4859 setup_sigcontext(struct target_sigcontext *sc, CPUM68KState *env, 4860 abi_ulong mask) 4861 { 4862 int err = 0; 4863 4864 err |= __put_user(mask, &sc->sc_mask); 4865 err |= __put_user(env->aregs[7], &sc->sc_usp); 4866 err |= __put_user(env->dregs[0], &sc->sc_d0); 4867 err |= __put_user(env->dregs[1], &sc->sc_d1); 4868 err |= __put_user(env->aregs[0], &sc->sc_a0); 4869 err |= __put_user(env->aregs[1], &sc->sc_a1); 4870 err |= __put_user(env->sr, &sc->sc_sr); 4871 err |= __put_user(env->pc, &sc->sc_pc); 4872 4873 return err; 4874 } 4875 4876 static int 4877 restore_sigcontext(CPUM68KState *env, struct target_sigcontext *sc, int *pd0) 4878 { 4879 int err = 0; 4880 int temp; 4881 4882 err |= __get_user(env->aregs[7], &sc->sc_usp); 4883 err |= __get_user(env->dregs[1], &sc->sc_d1); 4884 err |= __get_user(env->aregs[0], &sc->sc_a0); 4885 err |= __get_user(env->aregs[1], &sc->sc_a1); 4886 err |= __get_user(env->pc, &sc->sc_pc); 4887 err |= __get_user(temp, &sc->sc_sr); 4888 env->sr = (env->sr & 0xff00) | (temp & 0xff); 4889 4890 *pd0 = tswapl(sc->sc_d0); 4891 4892 return err; 4893 } 4894 4895 /* 4896 * Determine which stack to use.. 4897 */ 4898 static inline abi_ulong 4899 get_sigframe(struct target_sigaction *ka, CPUM68KState *regs, 4900 size_t frame_size) 4901 { 4902 unsigned long sp; 4903 4904 sp = regs->aregs[7]; 4905 4906 /* This is the X/Open sanctioned signal stack switching. */ 4907 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) { 4908 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 4909 } 4910 4911 return ((sp - frame_size) & -8UL); 4912 } 4913 4914 static void setup_frame(int sig, struct target_sigaction *ka, 4915 target_sigset_t *set, CPUM68KState *env) 4916 { 4917 struct target_sigframe *frame; 4918 abi_ulong frame_addr; 4919 abi_ulong retcode_addr; 4920 abi_ulong sc_addr; 4921 int err = 0; 4922 int i; 4923 4924 frame_addr = get_sigframe(ka, env, sizeof *frame); 4925 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 4926 goto give_sigsegv; 4927 4928 err |= __put_user(sig, &frame->sig); 4929 4930 sc_addr = frame_addr + offsetof(struct target_sigframe, sc); 4931 err |= __put_user(sc_addr, &frame->psc); 4932 4933 err |= setup_sigcontext(&frame->sc, env, set->sig[0]); 4934 if (err) 4935 goto give_sigsegv; 4936 4937 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 4938 if (__put_user(set->sig[i], &frame->extramask[i - 1])) 4939 goto give_sigsegv; 4940 } 4941 4942 /* Set up to return from userspace. */ 4943 4944 retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode); 4945 err |= __put_user(retcode_addr, &frame->pretcode); 4946 4947 /* moveq #,d0; trap #0 */ 4948 4949 err |= __put_user(0x70004e40 + (TARGET_NR_sigreturn << 16), 4950 (long *)(frame->retcode)); 4951 4952 if (err) 4953 goto give_sigsegv; 4954 4955 /* Set up to return from userspace */ 4956 4957 env->aregs[7] = frame_addr; 4958 env->pc = ka->_sa_handler; 4959 4960 unlock_user_struct(frame, frame_addr, 1); 4961 return; 4962 4963 give_sigsegv: 4964 unlock_user_struct(frame, frame_addr, 1); 4965 force_sig(TARGET_SIGSEGV); 4966 } 4967 4968 static inline int target_rt_setup_ucontext(struct target_ucontext *uc, 4969 CPUM68KState *env) 4970 { 4971 target_greg_t *gregs = uc->tuc_mcontext.gregs; 4972 int err; 4973 4974 err = __put_user(TARGET_MCONTEXT_VERSION, &uc->tuc_mcontext.version); 4975 err |= __put_user(env->dregs[0], &gregs[0]); 4976 err |= __put_user(env->dregs[1], &gregs[1]); 4977 err |= __put_user(env->dregs[2], &gregs[2]); 4978 err |= __put_user(env->dregs[3], &gregs[3]); 4979 err |= __put_user(env->dregs[4], &gregs[4]); 4980 err |= __put_user(env->dregs[5], &gregs[5]); 4981 err |= __put_user(env->dregs[6], &gregs[6]); 4982 err |= __put_user(env->dregs[7], &gregs[7]); 4983 err |= __put_user(env->aregs[0], &gregs[8]); 4984 err |= __put_user(env->aregs[1], &gregs[9]); 4985 err |= __put_user(env->aregs[2], &gregs[10]); 4986 err |= __put_user(env->aregs[3], &gregs[11]); 4987 err |= __put_user(env->aregs[4], &gregs[12]); 4988 err |= __put_user(env->aregs[5], &gregs[13]); 4989 err |= __put_user(env->aregs[6], &gregs[14]); 4990 err |= __put_user(env->aregs[7], &gregs[15]); 4991 err |= __put_user(env->pc, &gregs[16]); 4992 err |= __put_user(env->sr, &gregs[17]); 4993 4994 return err; 4995 } 4996 4997 static inline int target_rt_restore_ucontext(CPUM68KState *env, 4998 struct target_ucontext *uc, 4999 int *pd0) 5000 { 5001 int temp; 5002 int err; 5003 target_greg_t *gregs = uc->tuc_mcontext.gregs; 5004 5005 err = __get_user(temp, &uc->tuc_mcontext.version); 5006 if (temp != TARGET_MCONTEXT_VERSION) 5007 goto badframe; 5008 5009 /* restore passed registers */ 5010 err |= __get_user(env->dregs[0], &gregs[0]); 5011 err |= __get_user(env->dregs[1], &gregs[1]); 5012 err |= __get_user(env->dregs[2], &gregs[2]); 5013 err |= __get_user(env->dregs[3], &gregs[3]); 5014 err |= __get_user(env->dregs[4], &gregs[4]); 5015 err |= __get_user(env->dregs[5], &gregs[5]); 5016 err |= __get_user(env->dregs[6], &gregs[6]); 5017 err |= __get_user(env->dregs[7], &gregs[7]); 5018 err |= __get_user(env->aregs[0], &gregs[8]); 5019 err |= __get_user(env->aregs[1], &gregs[9]); 5020 err |= __get_user(env->aregs[2], &gregs[10]); 5021 err |= __get_user(env->aregs[3], &gregs[11]); 5022 err |= __get_user(env->aregs[4], &gregs[12]); 5023 err |= __get_user(env->aregs[5], &gregs[13]); 5024 err |= __get_user(env->aregs[6], &gregs[14]); 5025 err |= __get_user(env->aregs[7], &gregs[15]); 5026 err |= __get_user(env->pc, &gregs[16]); 5027 err |= __get_user(temp, &gregs[17]); 5028 env->sr = (env->sr & 0xff00) | (temp & 0xff); 5029 5030 *pd0 = env->dregs[0]; 5031 return err; 5032 5033 badframe: 5034 return 1; 5035 } 5036 5037 static void setup_rt_frame(int sig, struct target_sigaction *ka, 5038 target_siginfo_t *info, 5039 target_sigset_t *set, CPUM68KState *env) 5040 { 5041 struct target_rt_sigframe *frame; 5042 abi_ulong frame_addr; 5043 abi_ulong retcode_addr; 5044 abi_ulong info_addr; 5045 abi_ulong uc_addr; 5046 int err = 0; 5047 int i; 5048 5049 frame_addr = get_sigframe(ka, env, sizeof *frame); 5050 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 5051 goto give_sigsegv; 5052 5053 err |= __put_user(sig, &frame->sig); 5054 5055 info_addr = frame_addr + offsetof(struct target_rt_sigframe, info); 5056 err |= __put_user(info_addr, &frame->pinfo); 5057 5058 uc_addr = frame_addr + offsetof(struct target_rt_sigframe, uc); 5059 err |= __put_user(uc_addr, &frame->puc); 5060 5061 err |= copy_siginfo_to_user(&frame->info, info); 5062 5063 /* Create the ucontext */ 5064 5065 err |= __put_user(0, &frame->uc.tuc_flags); 5066 err |= __put_user(0, &frame->uc.tuc_link); 5067 err |= __put_user(target_sigaltstack_used.ss_sp, 5068 &frame->uc.tuc_stack.ss_sp); 5069 err |= __put_user(sas_ss_flags(env->aregs[7]), 5070 &frame->uc.tuc_stack.ss_flags); 5071 err |= __put_user(target_sigaltstack_used.ss_size, 5072 &frame->uc.tuc_stack.ss_size); 5073 err |= target_rt_setup_ucontext(&frame->uc, env); 5074 5075 if (err) 5076 goto give_sigsegv; 5077 5078 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 5079 if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i])) 5080 goto give_sigsegv; 5081 } 5082 5083 /* Set up to return from userspace. */ 5084 5085 retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode); 5086 err |= __put_user(retcode_addr, &frame->pretcode); 5087 5088 /* moveq #,d0; notb d0; trap #0 */ 5089 5090 err |= __put_user(0x70004600 + ((TARGET_NR_rt_sigreturn ^ 0xff) << 16), 5091 (long *)(frame->retcode + 0)); 5092 err |= __put_user(0x4e40, (short *)(frame->retcode + 4)); 5093 5094 if (err) 5095 goto give_sigsegv; 5096 5097 /* Set up to return from userspace */ 5098 5099 env->aregs[7] = frame_addr; 5100 env->pc = ka->_sa_handler; 5101 5102 unlock_user_struct(frame, frame_addr, 1); 5103 return; 5104 5105 give_sigsegv: 5106 unlock_user_struct(frame, frame_addr, 1); 5107 force_sig(TARGET_SIGSEGV); 5108 } 5109 5110 long do_sigreturn(CPUM68KState *env) 5111 { 5112 struct target_sigframe *frame; 5113 abi_ulong frame_addr = env->aregs[7] - 4; 5114 target_sigset_t target_set; 5115 sigset_t set; 5116 int d0, i; 5117 5118 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 5119 goto badframe; 5120 5121 /* set blocked signals */ 5122 5123 if (__get_user(target_set.sig[0], &frame->sc.sc_mask)) 5124 goto badframe; 5125 5126 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 5127 if (__get_user(target_set.sig[i], &frame->extramask[i - 1])) 5128 goto badframe; 5129 } 5130 5131 target_to_host_sigset_internal(&set, &target_set); 5132 sigprocmask(SIG_SETMASK, &set, NULL); 5133 5134 /* restore registers */ 5135 5136 if (restore_sigcontext(env, &frame->sc, &d0)) 5137 goto badframe; 5138 5139 unlock_user_struct(frame, frame_addr, 0); 5140 return d0; 5141 5142 badframe: 5143 unlock_user_struct(frame, frame_addr, 0); 5144 force_sig(TARGET_SIGSEGV); 5145 return 0; 5146 } 5147 5148 long do_rt_sigreturn(CPUM68KState *env) 5149 { 5150 struct target_rt_sigframe *frame; 5151 abi_ulong frame_addr = env->aregs[7] - 4; 5152 target_sigset_t target_set; 5153 sigset_t set; 5154 int d0; 5155 5156 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 5157 goto badframe; 5158 5159 target_to_host_sigset_internal(&set, &target_set); 5160 sigprocmask(SIG_SETMASK, &set, NULL); 5161 5162 /* restore registers */ 5163 5164 if (target_rt_restore_ucontext(env, &frame->uc, &d0)) 5165 goto badframe; 5166 5167 if (do_sigaltstack(frame_addr + 5168 offsetof(struct target_rt_sigframe, uc.tuc_stack), 5169 0, get_sp_from_cpustate(env)) == -EFAULT) 5170 goto badframe; 5171 5172 unlock_user_struct(frame, frame_addr, 0); 5173 return d0; 5174 5175 badframe: 5176 unlock_user_struct(frame, frame_addr, 0); 5177 force_sig(TARGET_SIGSEGV); 5178 return 0; 5179 } 5180 5181 #elif defined(TARGET_ALPHA) 5182 5183 struct target_sigcontext { 5184 abi_long sc_onstack; 5185 abi_long sc_mask; 5186 abi_long sc_pc; 5187 abi_long sc_ps; 5188 abi_long sc_regs[32]; 5189 abi_long sc_ownedfp; 5190 abi_long sc_fpregs[32]; 5191 abi_ulong sc_fpcr; 5192 abi_ulong sc_fp_control; 5193 abi_ulong sc_reserved1; 5194 abi_ulong sc_reserved2; 5195 abi_ulong sc_ssize; 5196 abi_ulong sc_sbase; 5197 abi_ulong sc_traparg_a0; 5198 abi_ulong sc_traparg_a1; 5199 abi_ulong sc_traparg_a2; 5200 abi_ulong sc_fp_trap_pc; 5201 abi_ulong sc_fp_trigger_sum; 5202 abi_ulong sc_fp_trigger_inst; 5203 }; 5204 5205 struct target_ucontext { 5206 abi_ulong tuc_flags; 5207 abi_ulong tuc_link; 5208 abi_ulong tuc_osf_sigmask; 5209 target_stack_t tuc_stack; 5210 struct target_sigcontext tuc_mcontext; 5211 target_sigset_t tuc_sigmask; 5212 }; 5213 5214 struct target_sigframe { 5215 struct target_sigcontext sc; 5216 unsigned int retcode[3]; 5217 }; 5218 5219 struct target_rt_sigframe { 5220 target_siginfo_t info; 5221 struct target_ucontext uc; 5222 unsigned int retcode[3]; 5223 }; 5224 5225 #define INSN_MOV_R30_R16 0x47fe0410 5226 #define INSN_LDI_R0 0x201f0000 5227 #define INSN_CALLSYS 0x00000083 5228 5229 static int setup_sigcontext(struct target_sigcontext *sc, CPUAlphaState *env, 5230 abi_ulong frame_addr, target_sigset_t *set) 5231 { 5232 int i, err = 0; 5233 5234 err |= __put_user(on_sig_stack(frame_addr), &sc->sc_onstack); 5235 err |= __put_user(set->sig[0], &sc->sc_mask); 5236 err |= __put_user(env->pc, &sc->sc_pc); 5237 err |= __put_user(8, &sc->sc_ps); 5238 5239 for (i = 0; i < 31; ++i) { 5240 err |= __put_user(env->ir[i], &sc->sc_regs[i]); 5241 } 5242 err |= __put_user(0, &sc->sc_regs[31]); 5243 5244 for (i = 0; i < 31; ++i) { 5245 err |= __put_user(env->fir[i], &sc->sc_fpregs[i]); 5246 } 5247 err |= __put_user(0, &sc->sc_fpregs[31]); 5248 err |= __put_user(cpu_alpha_load_fpcr(env), &sc->sc_fpcr); 5249 5250 err |= __put_user(0, &sc->sc_traparg_a0); /* FIXME */ 5251 err |= __put_user(0, &sc->sc_traparg_a1); /* FIXME */ 5252 err |= __put_user(0, &sc->sc_traparg_a2); /* FIXME */ 5253 5254 return err; 5255 } 5256 5257 static int restore_sigcontext(CPUAlphaState *env, 5258 struct target_sigcontext *sc) 5259 { 5260 uint64_t fpcr; 5261 int i, err = 0; 5262 5263 err |= __get_user(env->pc, &sc->sc_pc); 5264 5265 for (i = 0; i < 31; ++i) { 5266 err |= __get_user(env->ir[i], &sc->sc_regs[i]); 5267 } 5268 for (i = 0; i < 31; ++i) { 5269 err |= __get_user(env->fir[i], &sc->sc_fpregs[i]); 5270 } 5271 5272 err |= __get_user(fpcr, &sc->sc_fpcr); 5273 cpu_alpha_store_fpcr(env, fpcr); 5274 5275 return err; 5276 } 5277 5278 static inline abi_ulong get_sigframe(struct target_sigaction *sa, 5279 CPUAlphaState *env, 5280 unsigned long framesize) 5281 { 5282 abi_ulong sp = env->ir[IR_SP]; 5283 5284 /* This is the X/Open sanctioned signal stack switching. */ 5285 if ((sa->sa_flags & TARGET_SA_ONSTACK) != 0 && !sas_ss_flags(sp)) { 5286 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 5287 } 5288 return (sp - framesize) & -32; 5289 } 5290 5291 static void setup_frame(int sig, struct target_sigaction *ka, 5292 target_sigset_t *set, CPUAlphaState *env) 5293 { 5294 abi_ulong frame_addr, r26; 5295 struct target_sigframe *frame; 5296 int err = 0; 5297 5298 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 5299 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 5300 goto give_sigsegv; 5301 } 5302 5303 err |= setup_sigcontext(&frame->sc, env, frame_addr, set); 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_sigreturn, 5310 &frame->retcode[1]); 5311 err |= __put_user(INSN_CALLSYS, &frame->retcode[2]); 5312 /* imb() */ 5313 r26 = frame_addr; 5314 } 5315 5316 unlock_user_struct(frame, frame_addr, 1); 5317 5318 if (err) { 5319 give_sigsegv: 5320 if (sig == TARGET_SIGSEGV) { 5321 ka->_sa_handler = TARGET_SIG_DFL; 5322 } 5323 force_sig(TARGET_SIGSEGV); 5324 } 5325 5326 env->ir[IR_RA] = r26; 5327 env->ir[IR_PV] = env->pc = ka->_sa_handler; 5328 env->ir[IR_A0] = sig; 5329 env->ir[IR_A1] = 0; 5330 env->ir[IR_A2] = frame_addr + offsetof(struct target_sigframe, sc); 5331 env->ir[IR_SP] = frame_addr; 5332 } 5333 5334 static void setup_rt_frame(int sig, struct target_sigaction *ka, 5335 target_siginfo_t *info, 5336 target_sigset_t *set, CPUAlphaState *env) 5337 { 5338 abi_ulong frame_addr, r26; 5339 struct target_rt_sigframe *frame; 5340 int i, err = 0; 5341 5342 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 5343 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 5344 goto give_sigsegv; 5345 } 5346 5347 err |= copy_siginfo_to_user(&frame->info, info); 5348 5349 err |= __put_user(0, &frame->uc.tuc_flags); 5350 err |= __put_user(0, &frame->uc.tuc_link); 5351 err |= __put_user(set->sig[0], &frame->uc.tuc_osf_sigmask); 5352 err |= __put_user(target_sigaltstack_used.ss_sp, 5353 &frame->uc.tuc_stack.ss_sp); 5354 err |= __put_user(sas_ss_flags(env->ir[IR_SP]), 5355 &frame->uc.tuc_stack.ss_flags); 5356 err |= __put_user(target_sigaltstack_used.ss_size, 5357 &frame->uc.tuc_stack.ss_size); 5358 err |= setup_sigcontext(&frame->uc.tuc_mcontext, env, frame_addr, set); 5359 for (i = 0; i < TARGET_NSIG_WORDS; ++i) { 5360 err |= __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]); 5361 } 5362 5363 if (ka->sa_restorer) { 5364 r26 = ka->sa_restorer; 5365 } else { 5366 err |= __put_user(INSN_MOV_R30_R16, &frame->retcode[0]); 5367 err |= __put_user(INSN_LDI_R0 + TARGET_NR_rt_sigreturn, 5368 &frame->retcode[1]); 5369 err |= __put_user(INSN_CALLSYS, &frame->retcode[2]); 5370 /* imb(); */ 5371 r26 = frame_addr; 5372 } 5373 5374 if (err) { 5375 give_sigsegv: 5376 if (sig == TARGET_SIGSEGV) { 5377 ka->_sa_handler = TARGET_SIG_DFL; 5378 } 5379 force_sig(TARGET_SIGSEGV); 5380 } 5381 5382 env->ir[IR_RA] = r26; 5383 env->ir[IR_PV] = env->pc = ka->_sa_handler; 5384 env->ir[IR_A0] = sig; 5385 env->ir[IR_A1] = frame_addr + offsetof(struct target_rt_sigframe, info); 5386 env->ir[IR_A2] = frame_addr + offsetof(struct target_rt_sigframe, uc); 5387 env->ir[IR_SP] = frame_addr; 5388 } 5389 5390 long do_sigreturn(CPUAlphaState *env) 5391 { 5392 struct target_sigcontext *sc; 5393 abi_ulong sc_addr = env->ir[IR_A0]; 5394 target_sigset_t target_set; 5395 sigset_t set; 5396 5397 if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1)) { 5398 goto badframe; 5399 } 5400 5401 target_sigemptyset(&target_set); 5402 if (__get_user(target_set.sig[0], &sc->sc_mask)) { 5403 goto badframe; 5404 } 5405 5406 target_to_host_sigset_internal(&set, &target_set); 5407 sigprocmask(SIG_SETMASK, &set, NULL); 5408 5409 if (restore_sigcontext(env, sc)) { 5410 goto badframe; 5411 } 5412 unlock_user_struct(sc, sc_addr, 0); 5413 return env->ir[IR_V0]; 5414 5415 badframe: 5416 unlock_user_struct(sc, sc_addr, 0); 5417 force_sig(TARGET_SIGSEGV); 5418 } 5419 5420 long do_rt_sigreturn(CPUAlphaState *env) 5421 { 5422 abi_ulong frame_addr = env->ir[IR_A0]; 5423 struct target_rt_sigframe *frame; 5424 sigset_t set; 5425 5426 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) { 5427 goto badframe; 5428 } 5429 target_to_host_sigset(&set, &frame->uc.tuc_sigmask); 5430 sigprocmask(SIG_SETMASK, &set, NULL); 5431 5432 if (restore_sigcontext(env, &frame->uc.tuc_mcontext)) { 5433 goto badframe; 5434 } 5435 if (do_sigaltstack(frame_addr + offsetof(struct target_rt_sigframe, 5436 uc.tuc_stack), 5437 0, env->ir[IR_SP]) == -EFAULT) { 5438 goto badframe; 5439 } 5440 5441 unlock_user_struct(frame, frame_addr, 0); 5442 return env->ir[IR_V0]; 5443 5444 5445 badframe: 5446 unlock_user_struct(frame, frame_addr, 0); 5447 force_sig(TARGET_SIGSEGV); 5448 } 5449 5450 #else 5451 5452 static void setup_frame(int sig, struct target_sigaction *ka, 5453 target_sigset_t *set, CPUArchState *env) 5454 { 5455 fprintf(stderr, "setup_frame: not implemented\n"); 5456 } 5457 5458 static void setup_rt_frame(int sig, struct target_sigaction *ka, 5459 target_siginfo_t *info, 5460 target_sigset_t *set, CPUArchState *env) 5461 { 5462 fprintf(stderr, "setup_rt_frame: not implemented\n"); 5463 } 5464 5465 long do_sigreturn(CPUArchState *env) 5466 { 5467 fprintf(stderr, "do_sigreturn: not implemented\n"); 5468 return -TARGET_ENOSYS; 5469 } 5470 5471 long do_rt_sigreturn(CPUArchState *env) 5472 { 5473 fprintf(stderr, "do_rt_sigreturn: not implemented\n"); 5474 return -TARGET_ENOSYS; 5475 } 5476 5477 #endif 5478 5479 void process_pending_signals(CPUArchState *cpu_env) 5480 { 5481 int sig; 5482 abi_ulong handler; 5483 sigset_t set, old_set; 5484 target_sigset_t target_old_set; 5485 struct emulated_sigtable *k; 5486 struct target_sigaction *sa; 5487 struct sigqueue *q; 5488 TaskState *ts = cpu_env->opaque; 5489 5490 if (!ts->signal_pending) 5491 return; 5492 5493 /* FIXME: This is not threadsafe. */ 5494 k = ts->sigtab; 5495 for(sig = 1; sig <= TARGET_NSIG; sig++) { 5496 if (k->pending) 5497 goto handle_signal; 5498 k++; 5499 } 5500 /* if no signal is pending, just return */ 5501 ts->signal_pending = 0; 5502 return; 5503 5504 handle_signal: 5505 #ifdef DEBUG_SIGNAL 5506 fprintf(stderr, "qemu: process signal %d\n", sig); 5507 #endif 5508 /* dequeue signal */ 5509 q = k->first; 5510 k->first = q->next; 5511 if (!k->first) 5512 k->pending = 0; 5513 5514 sig = gdb_handlesig (cpu_env, sig); 5515 if (!sig) { 5516 sa = NULL; 5517 handler = TARGET_SIG_IGN; 5518 } else { 5519 sa = &sigact_table[sig - 1]; 5520 handler = sa->_sa_handler; 5521 } 5522 5523 if (handler == TARGET_SIG_DFL) { 5524 /* default handler : ignore some signal. The other are job control or fatal */ 5525 if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) { 5526 kill(getpid(),SIGSTOP); 5527 } else if (sig != TARGET_SIGCHLD && 5528 sig != TARGET_SIGURG && 5529 sig != TARGET_SIGWINCH && 5530 sig != TARGET_SIGCONT) { 5531 force_sig(sig); 5532 } 5533 } else if (handler == TARGET_SIG_IGN) { 5534 /* ignore sig */ 5535 } else if (handler == TARGET_SIG_ERR) { 5536 force_sig(sig); 5537 } else { 5538 /* compute the blocked signals during the handler execution */ 5539 target_to_host_sigset(&set, &sa->sa_mask); 5540 /* SA_NODEFER indicates that the current signal should not be 5541 blocked during the handler */ 5542 if (!(sa->sa_flags & TARGET_SA_NODEFER)) 5543 sigaddset(&set, target_to_host_signal(sig)); 5544 5545 /* block signals in the handler using Linux */ 5546 sigprocmask(SIG_BLOCK, &set, &old_set); 5547 /* save the previous blocked signal state to restore it at the 5548 end of the signal execution (see do_sigreturn) */ 5549 host_to_target_sigset_internal(&target_old_set, &old_set); 5550 5551 /* if the CPU is in VM86 mode, we restore the 32 bit values */ 5552 #if defined(TARGET_I386) && !defined(TARGET_X86_64) 5553 { 5554 CPUX86State *env = cpu_env; 5555 if (env->eflags & VM_MASK) 5556 save_v86_state(env); 5557 } 5558 #endif 5559 /* prepare the stack frame of the virtual CPU */ 5560 if (sa->sa_flags & TARGET_SA_SIGINFO) 5561 setup_rt_frame(sig, sa, &q->info, &target_old_set, cpu_env); 5562 else 5563 setup_frame(sig, sa, &target_old_set, cpu_env); 5564 if (sa->sa_flags & TARGET_SA_RESETHAND) 5565 sa->_sa_handler = TARGET_SIG_DFL; 5566 } 5567 if (q != &k->info) 5568 free_sigqueue(cpu_env, q); 5569 } 5570