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, write to the Free Software 18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 */ 20 #include <stdlib.h> 21 #include <stdio.h> 22 #include <string.h> 23 #include <stdarg.h> 24 #include <unistd.h> 25 #include <signal.h> 26 #include <errno.h> 27 #include <sys/ucontext.h> 28 29 #include "qemu.h" 30 #include "target_signal.h" 31 32 //#define DEBUG_SIGNAL 33 34 #define MAX_SIGQUEUE_SIZE 1024 35 36 struct sigqueue { 37 struct sigqueue *next; 38 target_siginfo_t info; 39 }; 40 41 struct emulated_sigaction { 42 struct target_sigaction sa; 43 int pending; /* true if signal is pending */ 44 struct sigqueue *first; 45 struct sigqueue info; /* in order to always have memory for the 46 first signal, we put it here */ 47 }; 48 49 struct target_sigaltstack target_sigaltstack_used = { 50 .ss_sp = 0, 51 .ss_size = 0, 52 .ss_flags = TARGET_SS_DISABLE, 53 }; 54 55 static struct emulated_sigaction sigact_table[TARGET_NSIG]; 56 static struct sigqueue sigqueue_table[MAX_SIGQUEUE_SIZE]; /* siginfo queue */ 57 static struct sigqueue *first_free; /* first free siginfo queue entry */ 58 static int signal_pending; /* non zero if a signal may be pending */ 59 60 static void host_signal_handler(int host_signum, siginfo_t *info, 61 void *puc); 62 63 static uint8_t host_to_target_signal_table[65] = { 64 [SIGHUP] = TARGET_SIGHUP, 65 [SIGINT] = TARGET_SIGINT, 66 [SIGQUIT] = TARGET_SIGQUIT, 67 [SIGILL] = TARGET_SIGILL, 68 [SIGTRAP] = TARGET_SIGTRAP, 69 [SIGABRT] = TARGET_SIGABRT, 70 /* [SIGIOT] = TARGET_SIGIOT,*/ 71 [SIGBUS] = TARGET_SIGBUS, 72 [SIGFPE] = TARGET_SIGFPE, 73 [SIGKILL] = TARGET_SIGKILL, 74 [SIGUSR1] = TARGET_SIGUSR1, 75 [SIGSEGV] = TARGET_SIGSEGV, 76 [SIGUSR2] = TARGET_SIGUSR2, 77 [SIGPIPE] = TARGET_SIGPIPE, 78 [SIGALRM] = TARGET_SIGALRM, 79 [SIGTERM] = TARGET_SIGTERM, 80 #ifdef SIGSTKFLT 81 [SIGSTKFLT] = TARGET_SIGSTKFLT, 82 #endif 83 [SIGCHLD] = TARGET_SIGCHLD, 84 [SIGCONT] = TARGET_SIGCONT, 85 [SIGSTOP] = TARGET_SIGSTOP, 86 [SIGTSTP] = TARGET_SIGTSTP, 87 [SIGTTIN] = TARGET_SIGTTIN, 88 [SIGTTOU] = TARGET_SIGTTOU, 89 [SIGURG] = TARGET_SIGURG, 90 [SIGXCPU] = TARGET_SIGXCPU, 91 [SIGXFSZ] = TARGET_SIGXFSZ, 92 [SIGVTALRM] = TARGET_SIGVTALRM, 93 [SIGPROF] = TARGET_SIGPROF, 94 [SIGWINCH] = TARGET_SIGWINCH, 95 [SIGIO] = TARGET_SIGIO, 96 [SIGPWR] = TARGET_SIGPWR, 97 [SIGSYS] = TARGET_SIGSYS, 98 /* next signals stay the same */ 99 }; 100 static uint8_t target_to_host_signal_table[65]; 101 102 static inline int on_sig_stack(unsigned long sp) 103 { 104 return (sp - target_sigaltstack_used.ss_sp 105 < target_sigaltstack_used.ss_size); 106 } 107 108 static inline int sas_ss_flags(unsigned long sp) 109 { 110 return (target_sigaltstack_used.ss_size == 0 ? SS_DISABLE 111 : on_sig_stack(sp) ? SS_ONSTACK : 0); 112 } 113 114 static inline int host_to_target_signal(int sig) 115 { 116 return host_to_target_signal_table[sig]; 117 } 118 119 static inline int target_to_host_signal(int sig) 120 { 121 return target_to_host_signal_table[sig]; 122 } 123 124 static void host_to_target_sigset_internal(target_sigset_t *d, 125 const sigset_t *s) 126 { 127 int i; 128 unsigned long sigmask; 129 uint32_t target_sigmask; 130 131 sigmask = ((unsigned long *)s)[0]; 132 target_sigmask = 0; 133 for(i = 0; i < 32; i++) { 134 if (sigmask & (1 << i)) 135 target_sigmask |= 1 << (host_to_target_signal(i + 1) - 1); 136 } 137 #if TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 32 138 d->sig[0] = target_sigmask; 139 for(i = 1;i < TARGET_NSIG_WORDS; i++) { 140 d->sig[i] = ((unsigned long *)s)[i]; 141 } 142 #elif TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64 && TARGET_NSIG_WORDS == 2 143 d->sig[0] = target_sigmask; 144 d->sig[1] = sigmask >> 32; 145 #else 146 /* XXX: do it */ 147 #endif 148 } 149 150 void host_to_target_sigset(target_sigset_t *d, const sigset_t *s) 151 { 152 target_sigset_t d1; 153 int i; 154 155 host_to_target_sigset_internal(&d1, s); 156 for(i = 0;i < TARGET_NSIG_WORDS; i++) 157 d->sig[i] = tswapl(d1.sig[i]); 158 } 159 160 void target_to_host_sigset_internal(sigset_t *d, const target_sigset_t *s) 161 { 162 int i; 163 unsigned long sigmask; 164 abi_ulong target_sigmask; 165 166 target_sigmask = s->sig[0]; 167 sigmask = 0; 168 for(i = 0; i < 32; i++) { 169 if (target_sigmask & (1 << i)) 170 sigmask |= 1 << (target_to_host_signal(i + 1) - 1); 171 } 172 #if TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 32 173 ((unsigned long *)d)[0] = sigmask; 174 for(i = 1;i < TARGET_NSIG_WORDS; i++) { 175 ((unsigned long *)d)[i] = s->sig[i]; 176 } 177 #elif TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64 && TARGET_NSIG_WORDS == 2 178 ((unsigned long *)d)[0] = sigmask | ((unsigned long)(s->sig[1]) << 32); 179 #else 180 /* XXX: do it */ 181 #endif /* TARGET_ABI_BITS */ 182 } 183 184 void target_to_host_sigset(sigset_t *d, const target_sigset_t *s) 185 { 186 target_sigset_t s1; 187 int i; 188 189 for(i = 0;i < TARGET_NSIG_WORDS; i++) 190 s1.sig[i] = tswapl(s->sig[i]); 191 target_to_host_sigset_internal(d, &s1); 192 } 193 194 void host_to_target_old_sigset(abi_ulong *old_sigset, 195 const sigset_t *sigset) 196 { 197 target_sigset_t d; 198 host_to_target_sigset(&d, sigset); 199 *old_sigset = d.sig[0]; 200 } 201 202 void target_to_host_old_sigset(sigset_t *sigset, 203 const abi_ulong *old_sigset) 204 { 205 target_sigset_t d; 206 int i; 207 208 d.sig[0] = *old_sigset; 209 for(i = 1;i < TARGET_NSIG_WORDS; i++) 210 d.sig[i] = 0; 211 target_to_host_sigset(sigset, &d); 212 } 213 214 /* siginfo conversion */ 215 216 static inline void host_to_target_siginfo_noswap(target_siginfo_t *tinfo, 217 const siginfo_t *info) 218 { 219 int sig; 220 sig = host_to_target_signal(info->si_signo); 221 tinfo->si_signo = sig; 222 tinfo->si_errno = 0; 223 tinfo->si_code = 0; 224 if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV || 225 sig == SIGBUS || sig == SIGTRAP) { 226 /* should never come here, but who knows. The information for 227 the target is irrelevant */ 228 tinfo->_sifields._sigfault._addr = 0; 229 } else if (sig == SIGIO) { 230 tinfo->_sifields._sigpoll._fd = info->si_fd; 231 } else if (sig >= TARGET_SIGRTMIN) { 232 tinfo->_sifields._rt._pid = info->si_pid; 233 tinfo->_sifields._rt._uid = info->si_uid; 234 /* XXX: potential problem if 64 bit */ 235 tinfo->_sifields._rt._sigval.sival_ptr = 236 (abi_ulong)(unsigned long)info->si_value.sival_ptr; 237 } 238 } 239 240 static void tswap_siginfo(target_siginfo_t *tinfo, 241 const target_siginfo_t *info) 242 { 243 int sig; 244 sig = info->si_signo; 245 tinfo->si_signo = tswap32(sig); 246 tinfo->si_errno = tswap32(info->si_errno); 247 tinfo->si_code = tswap32(info->si_code); 248 if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV || 249 sig == SIGBUS || sig == SIGTRAP) { 250 tinfo->_sifields._sigfault._addr = 251 tswapl(info->_sifields._sigfault._addr); 252 } else if (sig == SIGIO) { 253 tinfo->_sifields._sigpoll._fd = tswap32(info->_sifields._sigpoll._fd); 254 } else if (sig >= TARGET_SIGRTMIN) { 255 tinfo->_sifields._rt._pid = tswap32(info->_sifields._rt._pid); 256 tinfo->_sifields._rt._uid = tswap32(info->_sifields._rt._uid); 257 tinfo->_sifields._rt._sigval.sival_ptr = 258 tswapl(info->_sifields._rt._sigval.sival_ptr); 259 } 260 } 261 262 263 void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info) 264 { 265 host_to_target_siginfo_noswap(tinfo, info); 266 tswap_siginfo(tinfo, tinfo); 267 } 268 269 /* XXX: we support only POSIX RT signals are used. */ 270 /* XXX: find a solution for 64 bit (additional malloced data is needed) */ 271 void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo) 272 { 273 info->si_signo = tswap32(tinfo->si_signo); 274 info->si_errno = tswap32(tinfo->si_errno); 275 info->si_code = tswap32(tinfo->si_code); 276 info->si_pid = tswap32(tinfo->_sifields._rt._pid); 277 info->si_uid = tswap32(tinfo->_sifields._rt._uid); 278 info->si_value.sival_ptr = 279 (void *)(long)tswapl(tinfo->_sifields._rt._sigval.sival_ptr); 280 } 281 282 void signal_init(void) 283 { 284 struct sigaction act; 285 int i, j; 286 287 /* generate signal conversion tables */ 288 for(i = 1; i <= 64; i++) { 289 if (host_to_target_signal_table[i] == 0) 290 host_to_target_signal_table[i] = i; 291 } 292 for(i = 1; i <= 64; i++) { 293 j = host_to_target_signal_table[i]; 294 target_to_host_signal_table[j] = i; 295 } 296 297 /* set all host signal handlers. ALL signals are blocked during 298 the handlers to serialize them. */ 299 sigfillset(&act.sa_mask); 300 act.sa_flags = SA_SIGINFO; 301 act.sa_sigaction = host_signal_handler; 302 for(i = 1; i < NSIG; i++) { 303 sigaction(i, &act, NULL); 304 } 305 306 memset(sigact_table, 0, sizeof(sigact_table)); 307 308 first_free = &sigqueue_table[0]; 309 for(i = 0; i < MAX_SIGQUEUE_SIZE - 1; i++) 310 sigqueue_table[i].next = &sigqueue_table[i + 1]; 311 sigqueue_table[MAX_SIGQUEUE_SIZE - 1].next = NULL; 312 } 313 314 /* signal queue handling */ 315 316 static inline struct sigqueue *alloc_sigqueue(void) 317 { 318 struct sigqueue *q = first_free; 319 if (!q) 320 return NULL; 321 first_free = q->next; 322 return q; 323 } 324 325 static inline void free_sigqueue(struct sigqueue *q) 326 { 327 q->next = first_free; 328 first_free = q; 329 } 330 331 /* abort execution with signal */ 332 void __attribute((noreturn)) force_sig(int sig) 333 { 334 int host_sig; 335 host_sig = target_to_host_signal(sig); 336 fprintf(stderr, "qemu: uncaught target signal %d (%s) - exiting\n", 337 sig, strsignal(host_sig)); 338 #if 1 339 _exit(-host_sig); 340 #else 341 { 342 struct sigaction act; 343 sigemptyset(&act.sa_mask); 344 act.sa_flags = SA_SIGINFO; 345 act.sa_sigaction = SIG_DFL; 346 sigaction(SIGABRT, &act, NULL); 347 abort(); 348 } 349 #endif 350 } 351 352 /* queue a signal so that it will be send to the virtual CPU as soon 353 as possible */ 354 int queue_signal(int sig, target_siginfo_t *info) 355 { 356 struct emulated_sigaction *k; 357 struct sigqueue *q, **pq; 358 abi_ulong handler; 359 360 #if defined(DEBUG_SIGNAL) 361 fprintf(stderr, "queue_signal: sig=%d\n", 362 sig); 363 #endif 364 k = &sigact_table[sig - 1]; 365 handler = k->sa._sa_handler; 366 if (handler == TARGET_SIG_DFL) { 367 /* default handler : ignore some signal. The other are fatal */ 368 if (sig != TARGET_SIGCHLD && 369 sig != TARGET_SIGURG && 370 sig != TARGET_SIGWINCH) { 371 force_sig(sig); 372 } else { 373 return 0; /* indicate ignored */ 374 } 375 } else if (handler == TARGET_SIG_IGN) { 376 /* ignore signal */ 377 return 0; 378 } else if (handler == TARGET_SIG_ERR) { 379 force_sig(sig); 380 } else { 381 pq = &k->first; 382 if (sig < TARGET_SIGRTMIN) { 383 /* if non real time signal, we queue exactly one signal */ 384 if (!k->pending) 385 q = &k->info; 386 else 387 return 0; 388 } else { 389 if (!k->pending) { 390 /* first signal */ 391 q = &k->info; 392 } else { 393 q = alloc_sigqueue(); 394 if (!q) 395 return -EAGAIN; 396 while (*pq != NULL) 397 pq = &(*pq)->next; 398 } 399 } 400 *pq = q; 401 q->info = *info; 402 q->next = NULL; 403 k->pending = 1; 404 /* signal that a new signal is pending */ 405 signal_pending = 1; 406 return 1; /* indicates that the signal was queued */ 407 } 408 } 409 410 static void host_signal_handler(int host_signum, siginfo_t *info, 411 void *puc) 412 { 413 int sig; 414 target_siginfo_t tinfo; 415 416 /* the CPU emulator uses some host signals to detect exceptions, 417 we we forward to it some signals */ 418 if (host_signum == SIGSEGV || host_signum == SIGBUS) { 419 if (cpu_signal_handler(host_signum, info, puc)) 420 return; 421 } 422 423 /* get target signal number */ 424 sig = host_to_target_signal(host_signum); 425 if (sig < 1 || sig > TARGET_NSIG) 426 return; 427 #if defined(DEBUG_SIGNAL) 428 fprintf(stderr, "qemu: got signal %d\n", sig); 429 #endif 430 host_to_target_siginfo_noswap(&tinfo, info); 431 if (queue_signal(sig, &tinfo) == 1) { 432 /* interrupt the virtual CPU as soon as possible */ 433 cpu_interrupt(global_env, CPU_INTERRUPT_EXIT); 434 } 435 } 436 437 /* do_sigaltstack() returns target values and errnos. */ 438 /* compare linux/kernel/signal.c:do_sigaltstack() */ 439 abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp) 440 { 441 int ret; 442 struct target_sigaltstack oss; 443 444 /* XXX: test errors */ 445 if(uoss_addr) 446 { 447 __put_user(target_sigaltstack_used.ss_sp, &oss.ss_sp); 448 __put_user(target_sigaltstack_used.ss_size, &oss.ss_size); 449 __put_user(sas_ss_flags(sp), &oss.ss_flags); 450 } 451 452 if(uss_addr) 453 { 454 struct target_sigaltstack *uss; 455 struct target_sigaltstack ss; 456 457 ret = -TARGET_EFAULT; 458 if (!lock_user_struct(VERIFY_READ, uss, uss_addr, 1) 459 || __get_user(ss.ss_sp, &uss->ss_sp) 460 || __get_user(ss.ss_size, &uss->ss_size) 461 || __get_user(ss.ss_flags, &uss->ss_flags)) 462 goto out; 463 unlock_user_struct(uss, uss_addr, 0); 464 465 ret = -TARGET_EPERM; 466 if (on_sig_stack(sp)) 467 goto out; 468 469 ret = -TARGET_EINVAL; 470 if (ss.ss_flags != TARGET_SS_DISABLE 471 && ss.ss_flags != TARGET_SS_ONSTACK 472 && ss.ss_flags != 0) 473 goto out; 474 475 if (ss.ss_flags == TARGET_SS_DISABLE) { 476 ss.ss_size = 0; 477 ss.ss_sp = 0; 478 } else { 479 ret = -TARGET_ENOMEM; 480 if (ss.ss_size < MINSIGSTKSZ) 481 goto out; 482 } 483 484 target_sigaltstack_used.ss_sp = ss.ss_sp; 485 target_sigaltstack_used.ss_size = ss.ss_size; 486 } 487 488 if (uoss_addr) { 489 ret = -TARGET_EFAULT; 490 if (copy_to_user(uoss_addr, &oss, sizeof(oss))) 491 goto out; 492 } 493 494 ret = 0; 495 out: 496 return ret; 497 } 498 499 /* do_sigaction() return host values and errnos */ 500 int do_sigaction(int sig, const struct target_sigaction *act, 501 struct target_sigaction *oact) 502 { 503 struct emulated_sigaction *k; 504 struct sigaction act1; 505 int host_sig; 506 int ret = 0; 507 508 if (sig < 1 || sig > TARGET_NSIG || sig == SIGKILL || sig == SIGSTOP) 509 return -EINVAL; 510 k = &sigact_table[sig - 1]; 511 #if defined(DEBUG_SIGNAL) 512 fprintf(stderr, "sigaction sig=%d act=0x%08x, oact=0x%08x\n", 513 sig, (int)act, (int)oact); 514 #endif 515 if (oact) { 516 oact->_sa_handler = tswapl(k->sa._sa_handler); 517 oact->sa_flags = tswapl(k->sa.sa_flags); 518 #if !defined(TARGET_MIPS) 519 oact->sa_restorer = tswapl(k->sa.sa_restorer); 520 #endif 521 oact->sa_mask = k->sa.sa_mask; 522 } 523 if (act) { 524 k->sa._sa_handler = tswapl(act->_sa_handler); 525 k->sa.sa_flags = tswapl(act->sa_flags); 526 #if !defined(TARGET_MIPS) 527 k->sa.sa_restorer = tswapl(act->sa_restorer); 528 #endif 529 k->sa.sa_mask = act->sa_mask; 530 531 /* we update the host linux signal state */ 532 host_sig = target_to_host_signal(sig); 533 if (host_sig != SIGSEGV && host_sig != SIGBUS) { 534 sigfillset(&act1.sa_mask); 535 act1.sa_flags = SA_SIGINFO; 536 if (k->sa.sa_flags & TARGET_SA_RESTART) 537 act1.sa_flags |= SA_RESTART; 538 /* NOTE: it is important to update the host kernel signal 539 ignore state to avoid getting unexpected interrupted 540 syscalls */ 541 if (k->sa._sa_handler == TARGET_SIG_IGN) { 542 act1.sa_sigaction = (void *)SIG_IGN; 543 } else if (k->sa._sa_handler == TARGET_SIG_DFL) { 544 act1.sa_sigaction = (void *)SIG_DFL; 545 } else { 546 act1.sa_sigaction = host_signal_handler; 547 } 548 ret = sigaction(host_sig, &act1, NULL); 549 } 550 } 551 return ret; 552 } 553 554 #ifndef offsetof 555 #define offsetof(type, field) ((size_t) &((type *)0)->field) 556 #endif 557 558 static inline int copy_siginfo_to_user(target_siginfo_t *tinfo, 559 const target_siginfo_t *info) 560 { 561 tswap_siginfo(tinfo, info); 562 return 0; 563 } 564 565 static inline int current_exec_domain_sig(int sig) 566 { 567 return /* current->exec_domain && current->exec_domain->signal_invmap 568 && sig < 32 ? current->exec_domain->signal_invmap[sig] : */ sig; 569 } 570 571 #if defined(TARGET_I386) && TARGET_ABI_BITS == 32 572 573 /* from the Linux kernel */ 574 575 struct target_fpreg { 576 uint16_t significand[4]; 577 uint16_t exponent; 578 }; 579 580 struct target_fpxreg { 581 uint16_t significand[4]; 582 uint16_t exponent; 583 uint16_t padding[3]; 584 }; 585 586 struct target_xmmreg { 587 abi_ulong element[4]; 588 }; 589 590 struct target_fpstate { 591 /* Regular FPU environment */ 592 abi_ulong cw; 593 abi_ulong sw; 594 abi_ulong tag; 595 abi_ulong ipoff; 596 abi_ulong cssel; 597 abi_ulong dataoff; 598 abi_ulong datasel; 599 struct target_fpreg _st[8]; 600 uint16_t status; 601 uint16_t magic; /* 0xffff = regular FPU data only */ 602 603 /* FXSR FPU environment */ 604 abi_ulong _fxsr_env[6]; /* FXSR FPU env is ignored */ 605 abi_ulong mxcsr; 606 abi_ulong reserved; 607 struct target_fpxreg _fxsr_st[8]; /* FXSR FPU reg data is ignored */ 608 struct target_xmmreg _xmm[8]; 609 abi_ulong padding[56]; 610 }; 611 612 #define X86_FXSR_MAGIC 0x0000 613 614 struct target_sigcontext { 615 uint16_t gs, __gsh; 616 uint16_t fs, __fsh; 617 uint16_t es, __esh; 618 uint16_t ds, __dsh; 619 abi_ulong edi; 620 abi_ulong esi; 621 abi_ulong ebp; 622 abi_ulong esp; 623 abi_ulong ebx; 624 abi_ulong edx; 625 abi_ulong ecx; 626 abi_ulong eax; 627 abi_ulong trapno; 628 abi_ulong err; 629 abi_ulong eip; 630 uint16_t cs, __csh; 631 abi_ulong eflags; 632 abi_ulong esp_at_signal; 633 uint16_t ss, __ssh; 634 abi_ulong fpstate; /* pointer */ 635 abi_ulong oldmask; 636 abi_ulong cr2; 637 }; 638 639 struct target_ucontext { 640 abi_ulong tuc_flags; 641 abi_ulong tuc_link; 642 target_stack_t tuc_stack; 643 struct target_sigcontext tuc_mcontext; 644 target_sigset_t tuc_sigmask; /* mask last for extensibility */ 645 }; 646 647 struct sigframe 648 { 649 abi_ulong pretcode; 650 int sig; 651 struct target_sigcontext sc; 652 struct target_fpstate fpstate; 653 abi_ulong extramask[TARGET_NSIG_WORDS-1]; 654 char retcode[8]; 655 }; 656 657 struct rt_sigframe 658 { 659 abi_ulong pretcode; 660 int sig; 661 abi_ulong pinfo; 662 abi_ulong puc; 663 struct target_siginfo info; 664 struct target_ucontext uc; 665 struct target_fpstate fpstate; 666 char retcode[8]; 667 }; 668 669 /* 670 * Set up a signal frame. 671 */ 672 673 /* XXX: save x87 state */ 674 static int 675 setup_sigcontext(struct target_sigcontext *sc, struct target_fpstate *fpstate, 676 CPUX86State *env, abi_ulong mask, abi_ulong fpstate_addr) 677 { 678 int err = 0; 679 uint16_t magic; 680 681 /* already locked in setup_frame() */ 682 err |= __put_user(env->segs[R_GS].selector, (unsigned int *)&sc->gs); 683 err |= __put_user(env->segs[R_FS].selector, (unsigned int *)&sc->fs); 684 err |= __put_user(env->segs[R_ES].selector, (unsigned int *)&sc->es); 685 err |= __put_user(env->segs[R_DS].selector, (unsigned int *)&sc->ds); 686 err |= __put_user(env->regs[R_EDI], &sc->edi); 687 err |= __put_user(env->regs[R_ESI], &sc->esi); 688 err |= __put_user(env->regs[R_EBP], &sc->ebp); 689 err |= __put_user(env->regs[R_ESP], &sc->esp); 690 err |= __put_user(env->regs[R_EBX], &sc->ebx); 691 err |= __put_user(env->regs[R_EDX], &sc->edx); 692 err |= __put_user(env->regs[R_ECX], &sc->ecx); 693 err |= __put_user(env->regs[R_EAX], &sc->eax); 694 err |= __put_user(env->exception_index, &sc->trapno); 695 err |= __put_user(env->error_code, &sc->err); 696 err |= __put_user(env->eip, &sc->eip); 697 err |= __put_user(env->segs[R_CS].selector, (unsigned int *)&sc->cs); 698 err |= __put_user(env->eflags, &sc->eflags); 699 err |= __put_user(env->regs[R_ESP], &sc->esp_at_signal); 700 err |= __put_user(env->segs[R_SS].selector, (unsigned int *)&sc->ss); 701 702 cpu_x86_fsave(env, fpstate_addr, 1); 703 fpstate->status = fpstate->sw; 704 magic = 0xffff; 705 err |= __put_user(magic, &fpstate->magic); 706 err |= __put_user(fpstate_addr, &sc->fpstate); 707 708 /* non-iBCS2 extensions.. */ 709 err |= __put_user(mask, &sc->oldmask); 710 err |= __put_user(env->cr[2], &sc->cr2); 711 return err; 712 } 713 714 /* 715 * Determine which stack to use.. 716 */ 717 718 static inline abi_ulong 719 get_sigframe(struct emulated_sigaction *ka, CPUX86State *env, size_t frame_size) 720 { 721 unsigned long esp; 722 723 /* Default to using normal stack */ 724 esp = env->regs[R_ESP]; 725 /* This is the X/Open sanctioned signal stack switching. */ 726 if (ka->sa.sa_flags & TARGET_SA_ONSTACK) { 727 if (sas_ss_flags(esp) == 0) 728 esp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 729 } 730 731 /* This is the legacy signal stack switching. */ 732 else 733 if ((env->segs[R_SS].selector & 0xffff) != __USER_DS && 734 !(ka->sa.sa_flags & TARGET_SA_RESTORER) && 735 ka->sa.sa_restorer) { 736 esp = (unsigned long) ka->sa.sa_restorer; 737 } 738 return (esp - frame_size) & -8ul; 739 } 740 741 /* compare linux/arch/i386/kernel/signal.c:setup_frame() */ 742 static void setup_frame(int sig, struct emulated_sigaction *ka, 743 target_sigset_t *set, CPUX86State *env) 744 { 745 abi_ulong frame_addr; 746 struct sigframe *frame; 747 int i, err = 0; 748 749 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 750 751 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 752 goto give_sigsegv; 753 754 err |= __put_user(current_exec_domain_sig(sig), 755 &frame->sig); 756 if (err) 757 goto give_sigsegv; 758 759 setup_sigcontext(&frame->sc, &frame->fpstate, env, set->sig[0], 760 frame_addr + offsetof(struct sigframe, fpstate)); 761 if (err) 762 goto give_sigsegv; 763 764 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 765 if (__put_user(set->sig[i], &frame->extramask[i - 1])) 766 goto give_sigsegv; 767 } 768 769 /* Set up to return from userspace. If provided, use a stub 770 already in userspace. */ 771 if (ka->sa.sa_flags & TARGET_SA_RESTORER) { 772 err |= __put_user(ka->sa.sa_restorer, &frame->pretcode); 773 } else { 774 uint16_t val16; 775 abi_ulong retcode_addr; 776 retcode_addr = frame_addr + offsetof(struct sigframe, retcode); 777 err |= __put_user(retcode_addr, &frame->pretcode); 778 /* This is popl %eax ; movl $,%eax ; int $0x80 */ 779 val16 = 0xb858; 780 err |= __put_user(val16, (uint16_t *)(frame->retcode+0)); 781 err |= __put_user(TARGET_NR_sigreturn, (int *)(frame->retcode+2)); 782 val16 = 0x80cd; 783 err |= __put_user(val16, (uint16_t *)(frame->retcode+6)); 784 } 785 786 if (err) 787 goto give_sigsegv; 788 789 /* Set up registers for signal handler */ 790 env->regs[R_ESP] = frame_addr; 791 env->eip = ka->sa._sa_handler; 792 793 cpu_x86_load_seg(env, R_DS, __USER_DS); 794 cpu_x86_load_seg(env, R_ES, __USER_DS); 795 cpu_x86_load_seg(env, R_SS, __USER_DS); 796 cpu_x86_load_seg(env, R_CS, __USER_CS); 797 env->eflags &= ~TF_MASK; 798 799 unlock_user_struct(frame, frame_addr, 1); 800 801 return; 802 803 give_sigsegv: 804 unlock_user_struct(frame, frame_addr, 1); 805 if (sig == TARGET_SIGSEGV) 806 ka->sa._sa_handler = TARGET_SIG_DFL; 807 force_sig(TARGET_SIGSEGV /* , current */); 808 } 809 810 /* compare linux/arch/i386/kernel/signal.c:setup_rt_frame() */ 811 static void setup_rt_frame(int sig, struct emulated_sigaction *ka, 812 target_siginfo_t *info, 813 target_sigset_t *set, CPUX86State *env) 814 { 815 abi_ulong frame_addr, addr; 816 struct rt_sigframe *frame; 817 int i, err = 0; 818 819 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 820 821 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 822 goto give_sigsegv; 823 824 err |= __put_user(current_exec_domain_sig(sig), 825 &frame->sig); 826 addr = frame_addr + offsetof(struct rt_sigframe, info); 827 err |= __put_user(addr, &frame->pinfo); 828 addr = frame_addr + offsetof(struct rt_sigframe, uc); 829 err |= __put_user(addr, &frame->puc); 830 err |= copy_siginfo_to_user(&frame->info, info); 831 if (err) 832 goto give_sigsegv; 833 834 /* Create the ucontext. */ 835 err |= __put_user(0, &frame->uc.tuc_flags); 836 err |= __put_user(0, &frame->uc.tuc_link); 837 err |= __put_user(target_sigaltstack_used.ss_sp, 838 &frame->uc.tuc_stack.ss_sp); 839 err |= __put_user(sas_ss_flags(get_sp_from_cpustate(env)), 840 &frame->uc.tuc_stack.ss_flags); 841 err |= __put_user(target_sigaltstack_used.ss_size, 842 &frame->uc.tuc_stack.ss_size); 843 err |= setup_sigcontext(&frame->uc.tuc_mcontext, &frame->fpstate, 844 env, set->sig[0], 845 frame_addr + offsetof(struct rt_sigframe, fpstate)); 846 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 847 if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i])) 848 goto give_sigsegv; 849 } 850 851 /* Set up to return from userspace. If provided, use a stub 852 already in userspace. */ 853 if (ka->sa.sa_flags & TARGET_SA_RESTORER) { 854 err |= __put_user(ka->sa.sa_restorer, &frame->pretcode); 855 } else { 856 uint16_t val16; 857 addr = frame_addr + offsetof(struct rt_sigframe, retcode); 858 err |= __put_user(addr, &frame->pretcode); 859 /* This is movl $,%eax ; int $0x80 */ 860 err |= __put_user(0xb8, (char *)(frame->retcode+0)); 861 err |= __put_user(TARGET_NR_rt_sigreturn, (int *)(frame->retcode+1)); 862 val16 = 0x80cd; 863 err |= __put_user(val16, (uint16_t *)(frame->retcode+5)); 864 } 865 866 if (err) 867 goto give_sigsegv; 868 869 /* Set up registers for signal handler */ 870 env->regs[R_ESP] = frame_addr; 871 env->eip = ka->sa._sa_handler; 872 873 cpu_x86_load_seg(env, R_DS, __USER_DS); 874 cpu_x86_load_seg(env, R_ES, __USER_DS); 875 cpu_x86_load_seg(env, R_SS, __USER_DS); 876 cpu_x86_load_seg(env, R_CS, __USER_CS); 877 env->eflags &= ~TF_MASK; 878 879 unlock_user_struct(frame, frame_addr, 1); 880 881 return; 882 883 give_sigsegv: 884 unlock_user_struct(frame, frame_addr, 1); 885 if (sig == TARGET_SIGSEGV) 886 ka->sa._sa_handler = TARGET_SIG_DFL; 887 force_sig(TARGET_SIGSEGV /* , current */); 888 } 889 890 static int 891 restore_sigcontext(CPUX86State *env, struct target_sigcontext *sc, int *peax) 892 { 893 unsigned int err = 0; 894 abi_ulong fpstate_addr; 895 unsigned int tmpflags; 896 897 cpu_x86_load_seg(env, R_GS, tswap16(sc->gs)); 898 cpu_x86_load_seg(env, R_FS, tswap16(sc->fs)); 899 cpu_x86_load_seg(env, R_ES, tswap16(sc->es)); 900 cpu_x86_load_seg(env, R_DS, tswap16(sc->ds)); 901 902 env->regs[R_EDI] = tswapl(sc->edi); 903 env->regs[R_ESI] = tswapl(sc->esi); 904 env->regs[R_EBP] = tswapl(sc->ebp); 905 env->regs[R_ESP] = tswapl(sc->esp); 906 env->regs[R_EBX] = tswapl(sc->ebx); 907 env->regs[R_EDX] = tswapl(sc->edx); 908 env->regs[R_ECX] = tswapl(sc->ecx); 909 env->eip = tswapl(sc->eip); 910 911 cpu_x86_load_seg(env, R_CS, lduw(&sc->cs) | 3); 912 cpu_x86_load_seg(env, R_SS, lduw(&sc->ss) | 3); 913 914 tmpflags = tswapl(sc->eflags); 915 env->eflags = (env->eflags & ~0x40DD5) | (tmpflags & 0x40DD5); 916 // regs->orig_eax = -1; /* disable syscall checks */ 917 918 fpstate_addr = tswapl(sc->fpstate); 919 if (fpstate_addr != 0) { 920 if (!access_ok(VERIFY_READ, fpstate_addr, 921 sizeof(struct target_fpstate))) 922 goto badframe; 923 cpu_x86_frstor(env, fpstate_addr, 1); 924 } 925 926 *peax = tswapl(sc->eax); 927 return err; 928 badframe: 929 return 1; 930 } 931 932 long do_sigreturn(CPUX86State *env) 933 { 934 struct sigframe *frame; 935 abi_ulong frame_addr = env->regs[R_ESP] - 8; 936 target_sigset_t target_set; 937 sigset_t set; 938 int eax, i; 939 940 #if defined(DEBUG_SIGNAL) 941 fprintf(stderr, "do_sigreturn\n"); 942 #endif 943 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 944 goto badframe; 945 /* set blocked signals */ 946 if (__get_user(target_set.sig[0], &frame->sc.oldmask)) 947 goto badframe; 948 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 949 if (__get_user(target_set.sig[i], &frame->extramask[i - 1])) 950 goto badframe; 951 } 952 953 target_to_host_sigset_internal(&set, &target_set); 954 sigprocmask(SIG_SETMASK, &set, NULL); 955 956 /* restore registers */ 957 if (restore_sigcontext(env, &frame->sc, &eax)) 958 goto badframe; 959 unlock_user_struct(frame, frame_addr, 0); 960 return eax; 961 962 badframe: 963 unlock_user_struct(frame, frame_addr, 0); 964 force_sig(TARGET_SIGSEGV); 965 return 0; 966 } 967 968 long do_rt_sigreturn(CPUX86State *env) 969 { 970 abi_ulong frame_addr; 971 struct rt_sigframe *frame; 972 sigset_t set; 973 int eax; 974 975 frame_addr = env->regs[R_ESP] - 4; 976 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 977 goto badframe; 978 target_to_host_sigset(&set, &frame->uc.tuc_sigmask); 979 sigprocmask(SIG_SETMASK, &set, NULL); 980 981 if (restore_sigcontext(env, &frame->uc.tuc_mcontext, &eax)) 982 goto badframe; 983 984 if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe, uc.tuc_stack), 0, 985 get_sp_from_cpustate(env)) == -EFAULT) 986 goto badframe; 987 988 unlock_user_struct(frame, frame_addr, 0); 989 return eax; 990 991 badframe: 992 unlock_user_struct(frame, frame_addr, 0); 993 force_sig(TARGET_SIGSEGV); 994 return 0; 995 } 996 997 #elif defined(TARGET_ARM) 998 999 struct target_sigcontext { 1000 abi_ulong trap_no; 1001 abi_ulong error_code; 1002 abi_ulong oldmask; 1003 abi_ulong arm_r0; 1004 abi_ulong arm_r1; 1005 abi_ulong arm_r2; 1006 abi_ulong arm_r3; 1007 abi_ulong arm_r4; 1008 abi_ulong arm_r5; 1009 abi_ulong arm_r6; 1010 abi_ulong arm_r7; 1011 abi_ulong arm_r8; 1012 abi_ulong arm_r9; 1013 abi_ulong arm_r10; 1014 abi_ulong arm_fp; 1015 abi_ulong arm_ip; 1016 abi_ulong arm_sp; 1017 abi_ulong arm_lr; 1018 abi_ulong arm_pc; 1019 abi_ulong arm_cpsr; 1020 abi_ulong fault_address; 1021 }; 1022 1023 struct target_ucontext { 1024 abi_ulong tuc_flags; 1025 abi_ulong tuc_link; 1026 target_stack_t tuc_stack; 1027 struct target_sigcontext tuc_mcontext; 1028 target_sigset_t tuc_sigmask; /* mask last for extensibility */ 1029 }; 1030 1031 struct sigframe 1032 { 1033 struct target_sigcontext sc; 1034 abi_ulong extramask[TARGET_NSIG_WORDS-1]; 1035 abi_ulong retcode; 1036 }; 1037 1038 struct rt_sigframe 1039 { 1040 abi_ulong pinfo; 1041 abi_ulong puc; 1042 struct target_siginfo info; 1043 struct target_ucontext uc; 1044 abi_ulong retcode; 1045 }; 1046 1047 #define TARGET_CONFIG_CPU_32 1 1048 1049 /* 1050 * For ARM syscalls, we encode the syscall number into the instruction. 1051 */ 1052 #define SWI_SYS_SIGRETURN (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE)) 1053 #define SWI_SYS_RT_SIGRETURN (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE)) 1054 1055 /* 1056 * For Thumb syscalls, we pass the syscall number via r7. We therefore 1057 * need two 16-bit instructions. 1058 */ 1059 #define SWI_THUMB_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn)) 1060 #define SWI_THUMB_RT_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn)) 1061 1062 static const abi_ulong retcodes[4] = { 1063 SWI_SYS_SIGRETURN, SWI_THUMB_SIGRETURN, 1064 SWI_SYS_RT_SIGRETURN, SWI_THUMB_RT_SIGRETURN 1065 }; 1066 1067 1068 #define __put_user_error(x,p,e) __put_user(x, p) 1069 #define __get_user_error(x,p,e) __get_user(x, p) 1070 1071 static inline int valid_user_regs(CPUState *regs) 1072 { 1073 return 1; 1074 } 1075 1076 static int 1077 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/ 1078 CPUState *env, abi_ulong mask) 1079 { 1080 int err = 0; 1081 1082 __put_user_error(env->regs[0], &sc->arm_r0, err); 1083 __put_user_error(env->regs[1], &sc->arm_r1, err); 1084 __put_user_error(env->regs[2], &sc->arm_r2, err); 1085 __put_user_error(env->regs[3], &sc->arm_r3, err); 1086 __put_user_error(env->regs[4], &sc->arm_r4, err); 1087 __put_user_error(env->regs[5], &sc->arm_r5, err); 1088 __put_user_error(env->regs[6], &sc->arm_r6, err); 1089 __put_user_error(env->regs[7], &sc->arm_r7, err); 1090 __put_user_error(env->regs[8], &sc->arm_r8, err); 1091 __put_user_error(env->regs[9], &sc->arm_r9, err); 1092 __put_user_error(env->regs[10], &sc->arm_r10, err); 1093 __put_user_error(env->regs[11], &sc->arm_fp, err); 1094 __put_user_error(env->regs[12], &sc->arm_ip, err); 1095 __put_user_error(env->regs[13], &sc->arm_sp, err); 1096 __put_user_error(env->regs[14], &sc->arm_lr, err); 1097 __put_user_error(env->regs[15], &sc->arm_pc, err); 1098 #ifdef TARGET_CONFIG_CPU_32 1099 __put_user_error(cpsr_read(env), &sc->arm_cpsr, err); 1100 #endif 1101 1102 __put_user_error(/* current->thread.trap_no */ 0, &sc->trap_no, err); 1103 __put_user_error(/* current->thread.error_code */ 0, &sc->error_code, err); 1104 __put_user_error(/* current->thread.address */ 0, &sc->fault_address, err); 1105 __put_user_error(mask, &sc->oldmask, err); 1106 1107 return err; 1108 } 1109 1110 static inline abi_ulong 1111 get_sigframe(struct emulated_sigaction *ka, CPUState *regs, int framesize) 1112 { 1113 unsigned long sp = regs->regs[13]; 1114 1115 /* 1116 * This is the X/Open sanctioned signal stack switching. 1117 */ 1118 if ((ka->sa.sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp)) 1119 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 1120 /* 1121 * ATPCS B01 mandates 8-byte alignment 1122 */ 1123 return (sp - framesize) & ~7; 1124 } 1125 1126 static int 1127 setup_return(CPUState *env, struct emulated_sigaction *ka, 1128 abi_ulong *rc, abi_ulong frame_addr, int usig, abi_ulong rc_addr) 1129 { 1130 abi_ulong handler = ka->sa._sa_handler; 1131 abi_ulong retcode; 1132 int thumb = 0; 1133 #if defined(TARGET_CONFIG_CPU_32) 1134 #if 0 1135 abi_ulong cpsr = env->cpsr; 1136 1137 /* 1138 * Maybe we need to deliver a 32-bit signal to a 26-bit task. 1139 */ 1140 if (ka->sa.sa_flags & SA_THIRTYTWO) 1141 cpsr = (cpsr & ~MODE_MASK) | USR_MODE; 1142 1143 #ifdef CONFIG_ARM_THUMB 1144 if (elf_hwcap & HWCAP_THUMB) { 1145 /* 1146 * The LSB of the handler determines if we're going to 1147 * be using THUMB or ARM mode for this signal handler. 1148 */ 1149 thumb = handler & 1; 1150 1151 if (thumb) 1152 cpsr |= T_BIT; 1153 else 1154 cpsr &= ~T_BIT; 1155 } 1156 #endif /* CONFIG_ARM_THUMB */ 1157 #endif /* 0 */ 1158 #endif /* TARGET_CONFIG_CPU_32 */ 1159 1160 if (ka->sa.sa_flags & TARGET_SA_RESTORER) { 1161 retcode = ka->sa.sa_restorer; 1162 } else { 1163 unsigned int idx = thumb; 1164 1165 if (ka->sa.sa_flags & TARGET_SA_SIGINFO) 1166 idx += 2; 1167 1168 if (__put_user(retcodes[idx], rc)) 1169 return 1; 1170 #if 0 1171 flush_icache_range((abi_ulong)rc, 1172 (abi_ulong)(rc + 1)); 1173 #endif 1174 retcode = rc_addr + thumb; 1175 } 1176 1177 env->regs[0] = usig; 1178 env->regs[13] = frame_addr; 1179 env->regs[14] = retcode; 1180 env->regs[15] = handler & (thumb ? ~1 : ~3); 1181 1182 #if 0 1183 #ifdef TARGET_CONFIG_CPU_32 1184 env->cpsr = cpsr; 1185 #endif 1186 #endif 1187 1188 return 0; 1189 } 1190 1191 /* compare linux/arch/arm/kernel/signal.c:setup_frame() */ 1192 static void setup_frame(int usig, struct emulated_sigaction *ka, 1193 target_sigset_t *set, CPUState *regs) 1194 { 1195 struct sigframe *frame; 1196 abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame)); 1197 int i, err = 0; 1198 1199 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 1200 return; 1201 1202 err |= setup_sigcontext(&frame->sc, /*&frame->fpstate,*/ regs, set->sig[0]); 1203 1204 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 1205 if (__put_user(set->sig[i], &frame->extramask[i - 1])) 1206 goto end; 1207 } 1208 1209 if (err == 0) 1210 err = setup_return(regs, ka, &frame->retcode, frame_addr, usig, 1211 frame_addr + offsetof(struct sigframe, retcode)); 1212 1213 end: 1214 unlock_user_struct(frame, frame_addr, 1); 1215 // return err; 1216 } 1217 1218 /* compare linux/arch/arm/kernel/signal.c:setup_rt_frame() */ 1219 static void setup_rt_frame(int usig, struct emulated_sigaction *ka, 1220 target_siginfo_t *info, 1221 target_sigset_t *set, CPUState *env) 1222 { 1223 struct rt_sigframe *frame; 1224 abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame)); 1225 struct target_sigaltstack stack; 1226 int i, err = 0; 1227 abi_ulong info_addr, uc_addr; 1228 1229 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 1230 return /* 1 */; 1231 1232 info_addr = frame_addr + offsetof(struct rt_sigframe, info); 1233 __put_user_error(info_addr, &frame->pinfo, err); 1234 uc_addr = frame_addr + offsetof(struct rt_sigframe, uc); 1235 __put_user_error(uc_addr, &frame->puc, err); 1236 err |= copy_siginfo_to_user(&frame->info, info); 1237 1238 /* Clear all the bits of the ucontext we don't use. */ 1239 memset(&frame->uc, 0, offsetof(struct target_ucontext, tuc_mcontext)); 1240 1241 memset(&stack, 0, sizeof(stack)); 1242 __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp); 1243 __put_user(target_sigaltstack_used.ss_size, &stack.ss_size); 1244 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags); 1245 memcpy(&frame->uc.tuc_stack, &stack, sizeof(stack)); 1246 1247 err |= setup_sigcontext(&frame->uc.tuc_mcontext, /*&frame->fpstate,*/ 1248 env, set->sig[0]); 1249 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 1250 if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i])) 1251 goto end; 1252 } 1253 1254 if (err == 0) 1255 err = setup_return(env, ka, &frame->retcode, frame_addr, usig, 1256 frame_addr + offsetof(struct rt_sigframe, retcode)); 1257 1258 if (err == 0) { 1259 /* 1260 * For realtime signals we must also set the second and third 1261 * arguments for the signal handler. 1262 * -- Peter Maydell <pmaydell@chiark.greenend.org.uk> 2000-12-06 1263 */ 1264 env->regs[1] = info_addr; 1265 env->regs[2] = uc_addr; 1266 } 1267 1268 end: 1269 unlock_user_struct(frame, frame_addr, 1); 1270 1271 // return err; 1272 } 1273 1274 static int 1275 restore_sigcontext(CPUState *env, struct target_sigcontext *sc) 1276 { 1277 int err = 0; 1278 uint32_t cpsr; 1279 1280 __get_user_error(env->regs[0], &sc->arm_r0, err); 1281 __get_user_error(env->regs[1], &sc->arm_r1, err); 1282 __get_user_error(env->regs[2], &sc->arm_r2, err); 1283 __get_user_error(env->regs[3], &sc->arm_r3, err); 1284 __get_user_error(env->regs[4], &sc->arm_r4, err); 1285 __get_user_error(env->regs[5], &sc->arm_r5, err); 1286 __get_user_error(env->regs[6], &sc->arm_r6, err); 1287 __get_user_error(env->regs[7], &sc->arm_r7, err); 1288 __get_user_error(env->regs[8], &sc->arm_r8, err); 1289 __get_user_error(env->regs[9], &sc->arm_r9, err); 1290 __get_user_error(env->regs[10], &sc->arm_r10, err); 1291 __get_user_error(env->regs[11], &sc->arm_fp, err); 1292 __get_user_error(env->regs[12], &sc->arm_ip, err); 1293 __get_user_error(env->regs[13], &sc->arm_sp, err); 1294 __get_user_error(env->regs[14], &sc->arm_lr, err); 1295 __get_user_error(env->regs[15], &sc->arm_pc, err); 1296 #ifdef TARGET_CONFIG_CPU_32 1297 __get_user_error(cpsr, &sc->arm_cpsr, err); 1298 cpsr_write(env, cpsr, 0xffffffff); 1299 #endif 1300 1301 err |= !valid_user_regs(env); 1302 1303 return err; 1304 } 1305 1306 long do_sigreturn(CPUState *env) 1307 { 1308 abi_ulong frame_addr; 1309 struct sigframe *frame; 1310 target_sigset_t set; 1311 sigset_t host_set; 1312 int i; 1313 1314 /* 1315 * Since we stacked the signal on a 64-bit boundary, 1316 * then 'sp' should be word aligned here. If it's 1317 * not, then the user is trying to mess with us. 1318 */ 1319 if (env->regs[13] & 7) 1320 goto badframe; 1321 1322 frame_addr = env->regs[13]; 1323 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 1324 goto badframe; 1325 1326 if (__get_user(set.sig[0], &frame->sc.oldmask)) 1327 goto badframe; 1328 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 1329 if (__get_user(set.sig[i], &frame->extramask[i - 1])) 1330 goto badframe; 1331 } 1332 1333 target_to_host_sigset_internal(&host_set, &set); 1334 sigprocmask(SIG_SETMASK, &host_set, NULL); 1335 1336 if (restore_sigcontext(env, &frame->sc)) 1337 goto badframe; 1338 1339 #if 0 1340 /* Send SIGTRAP if we're single-stepping */ 1341 if (ptrace_cancel_bpt(current)) 1342 send_sig(SIGTRAP, current, 1); 1343 #endif 1344 unlock_user_struct(frame, frame_addr, 0); 1345 return env->regs[0]; 1346 1347 badframe: 1348 unlock_user_struct(frame, frame_addr, 0); 1349 force_sig(SIGSEGV /* , current */); 1350 return 0; 1351 } 1352 1353 long do_rt_sigreturn(CPUState *env) 1354 { 1355 abi_ulong frame_addr; 1356 struct rt_sigframe *frame; 1357 sigset_t host_set; 1358 1359 /* 1360 * Since we stacked the signal on a 64-bit boundary, 1361 * then 'sp' should be word aligned here. If it's 1362 * not, then the user is trying to mess with us. 1363 */ 1364 if (env->regs[13] & 7) 1365 goto badframe; 1366 1367 frame_addr = env->regs[13]; 1368 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 1369 goto badframe; 1370 1371 target_to_host_sigset(&host_set, &frame->uc.tuc_sigmask); 1372 sigprocmask(SIG_SETMASK, &host_set, NULL); 1373 1374 if (restore_sigcontext(env, &frame->uc.tuc_mcontext)) 1375 goto badframe; 1376 1377 if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe, uc.tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT) 1378 goto badframe; 1379 1380 #if 0 1381 /* Send SIGTRAP if we're single-stepping */ 1382 if (ptrace_cancel_bpt(current)) 1383 send_sig(SIGTRAP, current, 1); 1384 #endif 1385 unlock_user_struct(frame, frame_addr, 0); 1386 return env->regs[0]; 1387 1388 badframe: 1389 unlock_user_struct(frame, frame_addr, 0); 1390 force_sig(SIGSEGV /* , current */); 1391 return 0; 1392 } 1393 1394 #elif defined(TARGET_SPARC) 1395 1396 #define __SUNOS_MAXWIN 31 1397 1398 /* This is what SunOS does, so shall I. */ 1399 struct target_sigcontext { 1400 abi_ulong sigc_onstack; /* state to restore */ 1401 1402 abi_ulong sigc_mask; /* sigmask to restore */ 1403 abi_ulong sigc_sp; /* stack pointer */ 1404 abi_ulong sigc_pc; /* program counter */ 1405 abi_ulong sigc_npc; /* next program counter */ 1406 abi_ulong sigc_psr; /* for condition codes etc */ 1407 abi_ulong sigc_g1; /* User uses these two registers */ 1408 abi_ulong sigc_o0; /* within the trampoline code. */ 1409 1410 /* Now comes information regarding the users window set 1411 * at the time of the signal. 1412 */ 1413 abi_ulong sigc_oswins; /* outstanding windows */ 1414 1415 /* stack ptrs for each regwin buf */ 1416 char *sigc_spbuf[__SUNOS_MAXWIN]; 1417 1418 /* Windows to restore after signal */ 1419 struct { 1420 abi_ulong locals[8]; 1421 abi_ulong ins[8]; 1422 } sigc_wbuf[__SUNOS_MAXWIN]; 1423 }; 1424 /* A Sparc stack frame */ 1425 struct sparc_stackf { 1426 abi_ulong locals[8]; 1427 abi_ulong ins[6]; 1428 struct sparc_stackf *fp; 1429 abi_ulong callers_pc; 1430 char *structptr; 1431 abi_ulong xargs[6]; 1432 abi_ulong xxargs[1]; 1433 }; 1434 1435 typedef struct { 1436 struct { 1437 abi_ulong psr; 1438 abi_ulong pc; 1439 abi_ulong npc; 1440 abi_ulong y; 1441 abi_ulong u_regs[16]; /* globals and ins */ 1442 } si_regs; 1443 int si_mask; 1444 } __siginfo_t; 1445 1446 typedef struct { 1447 unsigned long si_float_regs [32]; 1448 unsigned long si_fsr; 1449 unsigned long si_fpqdepth; 1450 struct { 1451 unsigned long *insn_addr; 1452 unsigned long insn; 1453 } si_fpqueue [16]; 1454 } qemu_siginfo_fpu_t; 1455 1456 1457 struct target_signal_frame { 1458 struct sparc_stackf ss; 1459 __siginfo_t info; 1460 abi_ulong fpu_save; 1461 abi_ulong insns[2] __attribute__ ((aligned (8))); 1462 abi_ulong extramask[TARGET_NSIG_WORDS - 1]; 1463 abi_ulong extra_size; /* Should be 0 */ 1464 qemu_siginfo_fpu_t fpu_state; 1465 }; 1466 struct target_rt_signal_frame { 1467 struct sparc_stackf ss; 1468 siginfo_t info; 1469 abi_ulong regs[20]; 1470 sigset_t mask; 1471 abi_ulong fpu_save; 1472 unsigned int insns[2]; 1473 stack_t stack; 1474 unsigned int extra_size; /* Should be 0 */ 1475 qemu_siginfo_fpu_t fpu_state; 1476 }; 1477 1478 #define UREG_O0 16 1479 #define UREG_O6 22 1480 #define UREG_I0 0 1481 #define UREG_I1 1 1482 #define UREG_I2 2 1483 #define UREG_I3 3 1484 #define UREG_I4 4 1485 #define UREG_I5 5 1486 #define UREG_I6 6 1487 #define UREG_I7 7 1488 #define UREG_L0 8 1489 #define UREG_FP UREG_I6 1490 #define UREG_SP UREG_O6 1491 1492 static inline abi_ulong get_sigframe(struct emulated_sigaction *sa, 1493 CPUState *env, unsigned long framesize) 1494 { 1495 abi_ulong sp; 1496 1497 sp = env->regwptr[UREG_FP]; 1498 1499 /* This is the X/Open sanctioned signal stack switching. */ 1500 if (sa->sa.sa_flags & TARGET_SA_ONSTACK) { 1501 if (!on_sig_stack(sp) 1502 && !((target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size) & 7)) 1503 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 1504 } 1505 return sp - framesize; 1506 } 1507 1508 static int 1509 setup___siginfo(__siginfo_t *si, CPUState *env, abi_ulong mask) 1510 { 1511 int err = 0, i; 1512 1513 err |= __put_user(env->psr, &si->si_regs.psr); 1514 err |= __put_user(env->pc, &si->si_regs.pc); 1515 err |= __put_user(env->npc, &si->si_regs.npc); 1516 err |= __put_user(env->y, &si->si_regs.y); 1517 for (i=0; i < 8; i++) { 1518 err |= __put_user(env->gregs[i], &si->si_regs.u_regs[i]); 1519 } 1520 for (i=0; i < 8; i++) { 1521 err |= __put_user(env->regwptr[UREG_I0 + i], &si->si_regs.u_regs[i+8]); 1522 } 1523 err |= __put_user(mask, &si->si_mask); 1524 return err; 1525 } 1526 1527 #if 0 1528 static int 1529 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/ 1530 CPUState *env, unsigned long mask) 1531 { 1532 int err = 0; 1533 1534 err |= __put_user(mask, &sc->sigc_mask); 1535 err |= __put_user(env->regwptr[UREG_SP], &sc->sigc_sp); 1536 err |= __put_user(env->pc, &sc->sigc_pc); 1537 err |= __put_user(env->npc, &sc->sigc_npc); 1538 err |= __put_user(env->psr, &sc->sigc_psr); 1539 err |= __put_user(env->gregs[1], &sc->sigc_g1); 1540 err |= __put_user(env->regwptr[UREG_O0], &sc->sigc_o0); 1541 1542 return err; 1543 } 1544 #endif 1545 #define NF_ALIGNEDSZ (((sizeof(struct target_signal_frame) + 7) & (~7))) 1546 1547 static void setup_frame(int sig, struct emulated_sigaction *ka, 1548 target_sigset_t *set, CPUState *env) 1549 { 1550 abi_ulong sf_addr; 1551 struct target_signal_frame *sf; 1552 int sigframe_size, err, i; 1553 1554 /* 1. Make sure everything is clean */ 1555 //synchronize_user_stack(); 1556 1557 sigframe_size = NF_ALIGNEDSZ; 1558 sf_addr = get_sigframe(ka, env, sigframe_size); 1559 1560 sf = lock_user(VERIFY_WRITE, sf_addr, 1561 sizeof(struct target_signal_frame), 0); 1562 if (!sf) 1563 goto sigsegv; 1564 1565 //fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]); 1566 #if 0 1567 if (invalid_frame_pointer(sf, sigframe_size)) 1568 goto sigill_and_return; 1569 #endif 1570 /* 2. Save the current process state */ 1571 err = setup___siginfo(&sf->info, env, set->sig[0]); 1572 err |= __put_user(0, &sf->extra_size); 1573 1574 //err |= save_fpu_state(regs, &sf->fpu_state); 1575 //err |= __put_user(&sf->fpu_state, &sf->fpu_save); 1576 1577 err |= __put_user(set->sig[0], &sf->info.si_mask); 1578 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) { 1579 err |= __put_user(set->sig[i + 1], &sf->extramask[i]); 1580 } 1581 1582 for (i = 0; i < 8; i++) { 1583 err |= __put_user(env->regwptr[i + UREG_L0], &sf->ss.locals[i]); 1584 } 1585 for (i = 0; i < 8; i++) { 1586 err |= __put_user(env->regwptr[i + UREG_I0], &sf->ss.ins[i]); 1587 } 1588 if (err) 1589 goto sigsegv; 1590 1591 /* 3. signal handler back-trampoline and parameters */ 1592 env->regwptr[UREG_FP] = sf_addr; 1593 env->regwptr[UREG_I0] = sig; 1594 env->regwptr[UREG_I1] = sf_addr + 1595 offsetof(struct target_signal_frame, info); 1596 env->regwptr[UREG_I2] = sf_addr + 1597 offsetof(struct target_signal_frame, info); 1598 1599 /* 4. signal handler */ 1600 env->pc = ka->sa._sa_handler; 1601 env->npc = (env->pc + 4); 1602 /* 5. return to kernel instructions */ 1603 if (ka->sa.sa_restorer) 1604 env->regwptr[UREG_I7] = ka->sa.sa_restorer; 1605 else { 1606 uint32_t val32; 1607 1608 env->regwptr[UREG_I7] = sf_addr + 1609 offsetof(struct target_signal_frame, insns) - 2 * 4; 1610 1611 /* mov __NR_sigreturn, %g1 */ 1612 val32 = 0x821020d8; 1613 err |= __put_user(val32, &sf->insns[0]); 1614 1615 /* t 0x10 */ 1616 val32 = 0x91d02010; 1617 err |= __put_user(val32, &sf->insns[1]); 1618 if (err) 1619 goto sigsegv; 1620 1621 /* Flush instruction space. */ 1622 //flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0])); 1623 // tb_flush(env); 1624 } 1625 unlock_user(sf, sf_addr, sizeof(struct target_signal_frame)); 1626 return; 1627 #if 0 1628 sigill_and_return: 1629 force_sig(TARGET_SIGILL); 1630 #endif 1631 sigsegv: 1632 //fprintf(stderr, "force_sig\n"); 1633 unlock_user(sf, sf_addr, sizeof(struct target_signal_frame)); 1634 force_sig(TARGET_SIGSEGV); 1635 } 1636 static inline int 1637 restore_fpu_state(CPUState *env, qemu_siginfo_fpu_t *fpu) 1638 { 1639 int err; 1640 #if 0 1641 #ifdef CONFIG_SMP 1642 if (current->flags & PF_USEDFPU) 1643 regs->psr &= ~PSR_EF; 1644 #else 1645 if (current == last_task_used_math) { 1646 last_task_used_math = 0; 1647 regs->psr &= ~PSR_EF; 1648 } 1649 #endif 1650 current->used_math = 1; 1651 current->flags &= ~PF_USEDFPU; 1652 #endif 1653 #if 0 1654 if (verify_area (VERIFY_READ, fpu, sizeof(*fpu))) 1655 return -EFAULT; 1656 #endif 1657 1658 #if 0 1659 /* XXX: incorrect */ 1660 err = __copy_from_user(&env->fpr[0], &fpu->si_float_regs[0], 1661 (sizeof(unsigned long) * 32)); 1662 #endif 1663 err |= __get_user(env->fsr, &fpu->si_fsr); 1664 #if 0 1665 err |= __get_user(current->thread.fpqdepth, &fpu->si_fpqdepth); 1666 if (current->thread.fpqdepth != 0) 1667 err |= __copy_from_user(¤t->thread.fpqueue[0], 1668 &fpu->si_fpqueue[0], 1669 ((sizeof(unsigned long) + 1670 (sizeof(unsigned long *)))*16)); 1671 #endif 1672 return err; 1673 } 1674 1675 1676 static void setup_rt_frame(int sig, struct emulated_sigaction *ka, 1677 target_siginfo_t *info, 1678 target_sigset_t *set, CPUState *env) 1679 { 1680 fprintf(stderr, "setup_rt_frame: not implemented\n"); 1681 } 1682 1683 long do_sigreturn(CPUState *env) 1684 { 1685 abi_ulong sf_addr; 1686 struct target_signal_frame *sf; 1687 uint32_t up_psr, pc, npc; 1688 target_sigset_t set; 1689 sigset_t host_set; 1690 abi_ulong fpu_save_addr; 1691 int err, i; 1692 1693 sf_addr = env->regwptr[UREG_FP]; 1694 if (!lock_user_struct(VERIFY_READ, sf, sf_addr, 1)) 1695 goto segv_and_exit; 1696 #if 0 1697 fprintf(stderr, "sigreturn\n"); 1698 fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]); 1699 #endif 1700 //cpu_dump_state(env, stderr, fprintf, 0); 1701 1702 /* 1. Make sure we are not getting garbage from the user */ 1703 1704 if (sf_addr & 3) 1705 goto segv_and_exit; 1706 1707 err = __get_user(pc, &sf->info.si_regs.pc); 1708 err |= __get_user(npc, &sf->info.si_regs.npc); 1709 1710 if ((pc | npc) & 3) 1711 goto segv_and_exit; 1712 1713 /* 2. Restore the state */ 1714 err |= __get_user(up_psr, &sf->info.si_regs.psr); 1715 1716 /* User can only change condition codes and FPU enabling in %psr. */ 1717 env->psr = (up_psr & (PSR_ICC /* | PSR_EF */)) 1718 | (env->psr & ~(PSR_ICC /* | PSR_EF */)); 1719 1720 env->pc = pc; 1721 env->npc = npc; 1722 err |= __get_user(env->y, &sf->info.si_regs.y); 1723 for (i=0; i < 8; i++) { 1724 err |= __get_user(env->gregs[i], &sf->info.si_regs.u_regs[i]); 1725 } 1726 for (i=0; i < 8; i++) { 1727 err |= __get_user(env->regwptr[i + UREG_I0], &sf->info.si_regs.u_regs[i+8]); 1728 } 1729 1730 err |= __get_user(fpu_save_addr, &sf->fpu_save); 1731 1732 //if (fpu_save) 1733 // err |= restore_fpu_state(env, fpu_save); 1734 1735 /* This is pretty much atomic, no amount locking would prevent 1736 * the races which exist anyways. 1737 */ 1738 err |= __get_user(set.sig[0], &sf->info.si_mask); 1739 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 1740 err |= (__get_user(set.sig[i], &sf->extramask[i - 1])); 1741 } 1742 1743 target_to_host_sigset_internal(&host_set, &set); 1744 sigprocmask(SIG_SETMASK, &host_set, NULL); 1745 1746 if (err) 1747 goto segv_and_exit; 1748 unlock_user_struct(sf, sf_addr, 0); 1749 return env->regwptr[0]; 1750 1751 segv_and_exit: 1752 unlock_user_struct(sf, sf_addr, 0); 1753 force_sig(TARGET_SIGSEGV); 1754 } 1755 1756 long do_rt_sigreturn(CPUState *env) 1757 { 1758 fprintf(stderr, "do_rt_sigreturn: not implemented\n"); 1759 return -TARGET_ENOSYS; 1760 } 1761 1762 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32) 1763 #define MC_TSTATE 0 1764 #define MC_PC 1 1765 #define MC_NPC 2 1766 #define MC_Y 3 1767 #define MC_G1 4 1768 #define MC_G2 5 1769 #define MC_G3 6 1770 #define MC_G4 7 1771 #define MC_G5 8 1772 #define MC_G6 9 1773 #define MC_G7 10 1774 #define MC_O0 11 1775 #define MC_O1 12 1776 #define MC_O2 13 1777 #define MC_O3 14 1778 #define MC_O4 15 1779 #define MC_O5 16 1780 #define MC_O6 17 1781 #define MC_O7 18 1782 #define MC_NGREG 19 1783 1784 typedef abi_ulong target_mc_greg_t; 1785 typedef target_mc_greg_t target_mc_gregset_t[MC_NGREG]; 1786 1787 struct target_mc_fq { 1788 abi_ulong *mcfq_addr; 1789 uint32_t mcfq_insn; 1790 }; 1791 1792 struct target_mc_fpu { 1793 union { 1794 uint32_t sregs[32]; 1795 uint64_t dregs[32]; 1796 //uint128_t qregs[16]; 1797 } mcfpu_fregs; 1798 abi_ulong mcfpu_fsr; 1799 abi_ulong mcfpu_fprs; 1800 abi_ulong mcfpu_gsr; 1801 struct target_mc_fq *mcfpu_fq; 1802 unsigned char mcfpu_qcnt; 1803 unsigned char mcfpu_qentsz; 1804 unsigned char mcfpu_enab; 1805 }; 1806 typedef struct target_mc_fpu target_mc_fpu_t; 1807 1808 typedef struct { 1809 target_mc_gregset_t mc_gregs; 1810 target_mc_greg_t mc_fp; 1811 target_mc_greg_t mc_i7; 1812 target_mc_fpu_t mc_fpregs; 1813 } target_mcontext_t; 1814 1815 struct target_ucontext { 1816 struct target_ucontext *uc_link; 1817 abi_ulong uc_flags; 1818 target_sigset_t uc_sigmask; 1819 target_mcontext_t uc_mcontext; 1820 }; 1821 1822 /* A V9 register window */ 1823 struct target_reg_window { 1824 abi_ulong locals[8]; 1825 abi_ulong ins[8]; 1826 }; 1827 1828 #define TARGET_STACK_BIAS 2047 1829 1830 /* {set, get}context() needed for 64-bit SparcLinux userland. */ 1831 void sparc64_set_context(CPUSPARCState *env) 1832 { 1833 abi_ulong ucp_addr; 1834 struct target_ucontext *ucp; 1835 target_mc_gregset_t *grp; 1836 abi_ulong pc, npc, tstate; 1837 abi_ulong fp, i7, w_addr; 1838 unsigned char fenab; 1839 int err; 1840 unsigned int i; 1841 1842 ucp_addr = env->regwptr[UREG_I0]; 1843 if (!lock_user_struct(VERIFY_READ, ucp, ucp_addr, 1)) 1844 goto do_sigsegv; 1845 grp = &ucp->uc_mcontext.mc_gregs; 1846 err = __get_user(pc, &((*grp)[MC_PC])); 1847 err |= __get_user(npc, &((*grp)[MC_NPC])); 1848 if (err || ((pc | npc) & 3)) 1849 goto do_sigsegv; 1850 if (env->regwptr[UREG_I1]) { 1851 target_sigset_t target_set; 1852 sigset_t set; 1853 1854 if (TARGET_NSIG_WORDS == 1) { 1855 if (__get_user(target_set.sig[0], &ucp->uc_sigmask.sig[0])) 1856 goto do_sigsegv; 1857 } else { 1858 abi_ulong *src, *dst; 1859 src = ucp->uc_sigmask.sig; 1860 dst = target_set.sig; 1861 for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong); 1862 i++, dst++, src++) 1863 err |= __get_user(*dst, src); 1864 if (err) 1865 goto do_sigsegv; 1866 } 1867 target_to_host_sigset_internal(&set, &target_set); 1868 sigprocmask(SIG_SETMASK, &set, NULL); 1869 } 1870 env->pc = pc; 1871 env->npc = npc; 1872 err |= __get_user(env->y, &((*grp)[MC_Y])); 1873 err |= __get_user(tstate, &((*grp)[MC_TSTATE])); 1874 env->asi = (tstate >> 24) & 0xff; 1875 PUT_CCR(env, tstate >> 32); 1876 PUT_CWP64(env, tstate & 0x1f); 1877 err |= __get_user(env->gregs[1], (&(*grp)[MC_G1])); 1878 err |= __get_user(env->gregs[2], (&(*grp)[MC_G2])); 1879 err |= __get_user(env->gregs[3], (&(*grp)[MC_G3])); 1880 err |= __get_user(env->gregs[4], (&(*grp)[MC_G4])); 1881 err |= __get_user(env->gregs[5], (&(*grp)[MC_G5])); 1882 err |= __get_user(env->gregs[6], (&(*grp)[MC_G6])); 1883 err |= __get_user(env->gregs[7], (&(*grp)[MC_G7])); 1884 err |= __get_user(env->regwptr[UREG_I0], (&(*grp)[MC_O0])); 1885 err |= __get_user(env->regwptr[UREG_I1], (&(*grp)[MC_O1])); 1886 err |= __get_user(env->regwptr[UREG_I2], (&(*grp)[MC_O2])); 1887 err |= __get_user(env->regwptr[UREG_I3], (&(*grp)[MC_O3])); 1888 err |= __get_user(env->regwptr[UREG_I4], (&(*grp)[MC_O4])); 1889 err |= __get_user(env->regwptr[UREG_I5], (&(*grp)[MC_O5])); 1890 err |= __get_user(env->regwptr[UREG_I6], (&(*grp)[MC_O6])); 1891 err |= __get_user(env->regwptr[UREG_I7], (&(*grp)[MC_O7])); 1892 1893 err |= __get_user(fp, &(ucp->uc_mcontext.mc_fp)); 1894 err |= __get_user(i7, &(ucp->uc_mcontext.mc_i7)); 1895 1896 w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6]; 1897 if (put_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]), 1898 abi_ulong) != 0) 1899 goto do_sigsegv; 1900 if (put_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]), 1901 abi_ulong) != 0) 1902 goto do_sigsegv; 1903 err |= __get_user(fenab, &(ucp->uc_mcontext.mc_fpregs.mcfpu_enab)); 1904 err |= __get_user(env->fprs, &(ucp->uc_mcontext.mc_fpregs.mcfpu_fprs)); 1905 { 1906 uint32_t *src, *dst; 1907 src = ucp->uc_mcontext.mc_fpregs.mcfpu_fregs.sregs; 1908 dst = env->fpr; 1909 /* XXX: check that the CPU storage is the same as user context */ 1910 for (i = 0; i < 64; i++, dst++, src++) 1911 err |= __get_user(*dst, src); 1912 } 1913 err |= __get_user(env->fsr, 1914 &(ucp->uc_mcontext.mc_fpregs.mcfpu_fsr)); 1915 err |= __get_user(env->gsr, 1916 &(ucp->uc_mcontext.mc_fpregs.mcfpu_gsr)); 1917 if (err) 1918 goto do_sigsegv; 1919 unlock_user_struct(ucp, ucp_addr, 0); 1920 return; 1921 do_sigsegv: 1922 unlock_user_struct(ucp, ucp_addr, 0); 1923 force_sig(SIGSEGV); 1924 } 1925 1926 void sparc64_get_context(CPUSPARCState *env) 1927 { 1928 abi_ulong ucp_addr; 1929 struct target_ucontext *ucp; 1930 target_mc_gregset_t *grp; 1931 target_mcontext_t *mcp; 1932 abi_ulong fp, i7, w_addr; 1933 int err; 1934 unsigned int i; 1935 target_sigset_t target_set; 1936 sigset_t set; 1937 1938 ucp_addr = env->regwptr[UREG_I0]; 1939 if (!lock_user_struct(VERIFY_WRITE, ucp, ucp_addr, 0)) 1940 goto do_sigsegv; 1941 1942 mcp = &ucp->uc_mcontext; 1943 grp = &mcp->mc_gregs; 1944 1945 /* Skip over the trap instruction, first. */ 1946 env->pc = env->npc; 1947 env->npc += 4; 1948 1949 err = 0; 1950 1951 sigprocmask(0, NULL, &set); 1952 host_to_target_sigset_internal(&target_set, &set); 1953 if (TARGET_NSIG_WORDS == 1) { 1954 err |= __put_user(target_set.sig[0], 1955 (abi_ulong *)&ucp->uc_sigmask); 1956 } else { 1957 abi_ulong *src, *dst; 1958 src = target_set.sig; 1959 dst = ucp->uc_sigmask.sig; 1960 for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong); 1961 i++, dst++, src++) 1962 err |= __put_user(*src, dst); 1963 if (err) 1964 goto do_sigsegv; 1965 } 1966 1967 /* XXX: tstate must be saved properly */ 1968 // err |= __put_user(env->tstate, &((*grp)[MC_TSTATE])); 1969 err |= __put_user(env->pc, &((*grp)[MC_PC])); 1970 err |= __put_user(env->npc, &((*grp)[MC_NPC])); 1971 err |= __put_user(env->y, &((*grp)[MC_Y])); 1972 err |= __put_user(env->gregs[1], &((*grp)[MC_G1])); 1973 err |= __put_user(env->gregs[2], &((*grp)[MC_G2])); 1974 err |= __put_user(env->gregs[3], &((*grp)[MC_G3])); 1975 err |= __put_user(env->gregs[4], &((*grp)[MC_G4])); 1976 err |= __put_user(env->gregs[5], &((*grp)[MC_G5])); 1977 err |= __put_user(env->gregs[6], &((*grp)[MC_G6])); 1978 err |= __put_user(env->gregs[7], &((*grp)[MC_G7])); 1979 err |= __put_user(env->regwptr[UREG_I0], &((*grp)[MC_O0])); 1980 err |= __put_user(env->regwptr[UREG_I1], &((*grp)[MC_O1])); 1981 err |= __put_user(env->regwptr[UREG_I2], &((*grp)[MC_O2])); 1982 err |= __put_user(env->regwptr[UREG_I3], &((*grp)[MC_O3])); 1983 err |= __put_user(env->regwptr[UREG_I4], &((*grp)[MC_O4])); 1984 err |= __put_user(env->regwptr[UREG_I5], &((*grp)[MC_O5])); 1985 err |= __put_user(env->regwptr[UREG_I6], &((*grp)[MC_O6])); 1986 err |= __put_user(env->regwptr[UREG_I7], &((*grp)[MC_O7])); 1987 1988 w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6]; 1989 fp = i7 = 0; 1990 if (get_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]), 1991 abi_ulong) != 0) 1992 goto do_sigsegv; 1993 if (get_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]), 1994 abi_ulong) != 0) 1995 goto do_sigsegv; 1996 err |= __put_user(fp, &(mcp->mc_fp)); 1997 err |= __put_user(i7, &(mcp->mc_i7)); 1998 1999 { 2000 uint32_t *src, *dst; 2001 src = env->fpr; 2002 dst = ucp->uc_mcontext.mc_fpregs.mcfpu_fregs.sregs; 2003 /* XXX: check that the CPU storage is the same as user context */ 2004 for (i = 0; i < 64; i++, dst++, src++) 2005 err |= __put_user(*src, dst); 2006 } 2007 err |= __put_user(env->fsr, &(mcp->mc_fpregs.mcfpu_fsr)); 2008 err |= __put_user(env->gsr, &(mcp->mc_fpregs.mcfpu_gsr)); 2009 err |= __put_user(env->fprs, &(mcp->mc_fpregs.mcfpu_fprs)); 2010 2011 if (err) 2012 goto do_sigsegv; 2013 unlock_user_struct(ucp, ucp_addr, 1); 2014 return; 2015 do_sigsegv: 2016 unlock_user_struct(ucp, ucp_addr, 1); 2017 force_sig(SIGSEGV); 2018 } 2019 #endif 2020 #elif defined(TARGET_ABI_MIPSN64) 2021 2022 # warning signal handling not implemented 2023 2024 static void setup_frame(int sig, struct emulated_sigaction *ka, 2025 target_sigset_t *set, CPUState *env) 2026 { 2027 fprintf(stderr, "setup_frame: not implemented\n"); 2028 } 2029 2030 static void setup_rt_frame(int sig, struct emulated_sigaction *ka, 2031 target_siginfo_t *info, 2032 target_sigset_t *set, CPUState *env) 2033 { 2034 fprintf(stderr, "setup_rt_frame: not implemented\n"); 2035 } 2036 2037 long do_sigreturn(CPUState *env) 2038 { 2039 fprintf(stderr, "do_sigreturn: not implemented\n"); 2040 return -TARGET_ENOSYS; 2041 } 2042 2043 long do_rt_sigreturn(CPUState *env) 2044 { 2045 fprintf(stderr, "do_rt_sigreturn: not implemented\n"); 2046 return -TARGET_ENOSYS; 2047 } 2048 2049 #elif defined(TARGET_ABI_MIPSN32) 2050 2051 # warning signal handling not implemented 2052 2053 static void setup_frame(int sig, struct emulated_sigaction *ka, 2054 target_sigset_t *set, CPUState *env) 2055 { 2056 fprintf(stderr, "setup_frame: not implemented\n"); 2057 } 2058 2059 static void setup_rt_frame(int sig, struct emulated_sigaction *ka, 2060 target_siginfo_t *info, 2061 target_sigset_t *set, CPUState *env) 2062 { 2063 fprintf(stderr, "setup_rt_frame: not implemented\n"); 2064 } 2065 2066 long do_sigreturn(CPUState *env) 2067 { 2068 fprintf(stderr, "do_sigreturn: not implemented\n"); 2069 return -TARGET_ENOSYS; 2070 } 2071 2072 long do_rt_sigreturn(CPUState *env) 2073 { 2074 fprintf(stderr, "do_rt_sigreturn: not implemented\n"); 2075 return -TARGET_ENOSYS; 2076 } 2077 2078 #elif defined(TARGET_ABI_MIPSO32) 2079 2080 struct target_sigcontext { 2081 uint32_t sc_regmask; /* Unused */ 2082 uint32_t sc_status; 2083 uint64_t sc_pc; 2084 uint64_t sc_regs[32]; 2085 uint64_t sc_fpregs[32]; 2086 uint32_t sc_ownedfp; /* Unused */ 2087 uint32_t sc_fpc_csr; 2088 uint32_t sc_fpc_eir; /* Unused */ 2089 uint32_t sc_used_math; 2090 uint32_t sc_dsp; /* dsp status, was sc_ssflags */ 2091 uint64_t sc_mdhi; 2092 uint64_t sc_mdlo; 2093 target_ulong sc_hi1; /* Was sc_cause */ 2094 target_ulong sc_lo1; /* Was sc_badvaddr */ 2095 target_ulong sc_hi2; /* Was sc_sigset[4] */ 2096 target_ulong sc_lo2; 2097 target_ulong sc_hi3; 2098 target_ulong sc_lo3; 2099 }; 2100 2101 struct sigframe { 2102 uint32_t sf_ass[4]; /* argument save space for o32 */ 2103 uint32_t sf_code[2]; /* signal trampoline */ 2104 struct target_sigcontext sf_sc; 2105 target_sigset_t sf_mask; 2106 }; 2107 2108 /* Install trampoline to jump back from signal handler */ 2109 static inline int install_sigtramp(unsigned int *tramp, unsigned int syscall) 2110 { 2111 int err; 2112 2113 /* 2114 * Set up the return code ... 2115 * 2116 * li v0, __NR__foo_sigreturn 2117 * syscall 2118 */ 2119 2120 err = __put_user(0x24020000 + syscall, tramp + 0); 2121 err |= __put_user(0x0000000c , tramp + 1); 2122 /* flush_cache_sigtramp((unsigned long) tramp); */ 2123 return err; 2124 } 2125 2126 static inline int 2127 setup_sigcontext(CPUState *regs, struct target_sigcontext *sc) 2128 { 2129 int err = 0; 2130 2131 err |= __put_user(regs->PC[regs->current_tc], &sc->sc_pc); 2132 2133 #define save_gp_reg(i) do { \ 2134 err |= __put_user(regs->gpr[regs->current_tc][i], &sc->sc_regs[i]); \ 2135 } while(0) 2136 __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2); 2137 save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6); 2138 save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10); 2139 save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14); 2140 save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18); 2141 save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22); 2142 save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26); 2143 save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30); 2144 save_gp_reg(31); 2145 #undef save_gp_reg 2146 2147 err |= __put_user(regs->HI[regs->current_tc][0], &sc->sc_mdhi); 2148 err |= __put_user(regs->LO[regs->current_tc][0], &sc->sc_mdlo); 2149 2150 /* Not used yet, but might be useful if we ever have DSP suppport */ 2151 #if 0 2152 if (cpu_has_dsp) { 2153 err |= __put_user(mfhi1(), &sc->sc_hi1); 2154 err |= __put_user(mflo1(), &sc->sc_lo1); 2155 err |= __put_user(mfhi2(), &sc->sc_hi2); 2156 err |= __put_user(mflo2(), &sc->sc_lo2); 2157 err |= __put_user(mfhi3(), &sc->sc_hi3); 2158 err |= __put_user(mflo3(), &sc->sc_lo3); 2159 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp); 2160 } 2161 /* same with 64 bit */ 2162 #ifdef CONFIG_64BIT 2163 err |= __put_user(regs->hi, &sc->sc_hi[0]); 2164 err |= __put_user(regs->lo, &sc->sc_lo[0]); 2165 if (cpu_has_dsp) { 2166 err |= __put_user(mfhi1(), &sc->sc_hi[1]); 2167 err |= __put_user(mflo1(), &sc->sc_lo[1]); 2168 err |= __put_user(mfhi2(), &sc->sc_hi[2]); 2169 err |= __put_user(mflo2(), &sc->sc_lo[2]); 2170 err |= __put_user(mfhi3(), &sc->sc_hi[3]); 2171 err |= __put_user(mflo3(), &sc->sc_lo[3]); 2172 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp); 2173 } 2174 #endif 2175 #endif 2176 2177 #if 0 2178 err |= __put_user(!!used_math(), &sc->sc_used_math); 2179 2180 if (!used_math()) 2181 goto out; 2182 2183 /* 2184 * Save FPU state to signal context. Signal handler will "inherit" 2185 * current FPU state. 2186 */ 2187 preempt_disable(); 2188 2189 if (!is_fpu_owner()) { 2190 own_fpu(); 2191 restore_fp(current); 2192 } 2193 err |= save_fp_context(sc); 2194 2195 preempt_enable(); 2196 out: 2197 #endif 2198 return err; 2199 } 2200 2201 static inline int 2202 restore_sigcontext(CPUState *regs, struct target_sigcontext *sc) 2203 { 2204 int err = 0; 2205 2206 err |= __get_user(regs->CP0_EPC, &sc->sc_pc); 2207 2208 err |= __get_user(regs->HI[regs->current_tc][0], &sc->sc_mdhi); 2209 err |= __get_user(regs->LO[regs->current_tc][0], &sc->sc_mdlo); 2210 2211 #define restore_gp_reg(i) do { \ 2212 err |= __get_user(regs->gpr[regs->current_tc][i], &sc->sc_regs[i]); \ 2213 } while(0) 2214 restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3); 2215 restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6); 2216 restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9); 2217 restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12); 2218 restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15); 2219 restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18); 2220 restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21); 2221 restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24); 2222 restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27); 2223 restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30); 2224 restore_gp_reg(31); 2225 #undef restore_gp_reg 2226 2227 #if 0 2228 if (cpu_has_dsp) { 2229 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg); 2230 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg); 2231 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg); 2232 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg); 2233 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg); 2234 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg); 2235 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK); 2236 } 2237 #ifdef CONFIG_64BIT 2238 err |= __get_user(regs->hi, &sc->sc_hi[0]); 2239 err |= __get_user(regs->lo, &sc->sc_lo[0]); 2240 if (cpu_has_dsp) { 2241 err |= __get_user(treg, &sc->sc_hi[1]); mthi1(treg); 2242 err |= __get_user(treg, &sc->sc_lo[1]); mthi1(treg); 2243 err |= __get_user(treg, &sc->sc_hi[2]); mthi2(treg); 2244 err |= __get_user(treg, &sc->sc_lo[2]); mthi2(treg); 2245 err |= __get_user(treg, &sc->sc_hi[3]); mthi3(treg); 2246 err |= __get_user(treg, &sc->sc_lo[3]); mthi3(treg); 2247 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK); 2248 } 2249 #endif 2250 2251 err |= __get_user(used_math, &sc->sc_used_math); 2252 conditional_used_math(used_math); 2253 2254 preempt_disable(); 2255 2256 if (used_math()) { 2257 /* restore fpu context if we have used it before */ 2258 own_fpu(); 2259 err |= restore_fp_context(sc); 2260 } else { 2261 /* signal handler may have used FPU. Give it up. */ 2262 lose_fpu(); 2263 } 2264 2265 preempt_enable(); 2266 #endif 2267 return err; 2268 } 2269 /* 2270 * Determine which stack to use.. 2271 */ 2272 static inline abi_ulong 2273 get_sigframe(struct emulated_sigaction *ka, CPUState *regs, size_t frame_size) 2274 { 2275 unsigned long sp; 2276 2277 /* Default to using normal stack */ 2278 sp = regs->gpr[regs->current_tc][29]; 2279 2280 /* 2281 * FPU emulator may have it's own trampoline active just 2282 * above the user stack, 16-bytes before the next lowest 2283 * 16 byte boundary. Try to avoid trashing it. 2284 */ 2285 sp -= 32; 2286 2287 /* This is the X/Open sanctioned signal stack switching. */ 2288 if ((ka->sa.sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) { 2289 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 2290 } 2291 2292 return (sp - frame_size) & ~7; 2293 } 2294 2295 /* compare linux/arch/mips/kernel/signal.c:setup_frame() */ 2296 static void setup_frame(int sig, struct emulated_sigaction * ka, 2297 target_sigset_t *set, CPUState *regs) 2298 { 2299 struct sigframe *frame; 2300 abi_ulong frame_addr; 2301 int i; 2302 2303 frame_addr = get_sigframe(ka, regs, sizeof(*frame)); 2304 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 2305 goto give_sigsegv; 2306 2307 install_sigtramp(frame->sf_code, TARGET_NR_sigreturn); 2308 2309 if(setup_sigcontext(regs, &frame->sf_sc)) 2310 goto give_sigsegv; 2311 2312 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 2313 if(__put_user(set->sig[i], &frame->sf_mask.sig[i])) 2314 goto give_sigsegv; 2315 } 2316 2317 /* 2318 * Arguments to signal handler: 2319 * 2320 * a0 = signal number 2321 * a1 = 0 (should be cause) 2322 * a2 = pointer to struct sigcontext 2323 * 2324 * $25 and PC point to the signal handler, $29 points to the 2325 * struct sigframe. 2326 */ 2327 regs->gpr[regs->current_tc][ 4] = sig; 2328 regs->gpr[regs->current_tc][ 5] = 0; 2329 regs->gpr[regs->current_tc][ 6] = frame_addr + offsetof(struct sigframe, sf_sc); 2330 regs->gpr[regs->current_tc][29] = frame_addr; 2331 regs->gpr[regs->current_tc][31] = frame_addr + offsetof(struct sigframe, sf_code); 2332 /* The original kernel code sets CP0_EPC to the handler 2333 * since it returns to userland using eret 2334 * we cannot do this here, and we must set PC directly */ 2335 regs->PC[regs->current_tc] = regs->gpr[regs->current_tc][25] = ka->sa._sa_handler; 2336 unlock_user_struct(frame, frame_addr, 1); 2337 return; 2338 2339 give_sigsegv: 2340 unlock_user_struct(frame, frame_addr, 1); 2341 force_sig(TARGET_SIGSEGV/*, current*/); 2342 return; 2343 } 2344 2345 long do_sigreturn(CPUState *regs) 2346 { 2347 struct sigframe *frame; 2348 abi_ulong frame_addr; 2349 sigset_t blocked; 2350 target_sigset_t target_set; 2351 int i; 2352 2353 #if defined(DEBUG_SIGNAL) 2354 fprintf(stderr, "do_sigreturn\n"); 2355 #endif 2356 frame_addr = regs->gpr[regs->current_tc][29]; 2357 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 2358 goto badframe; 2359 2360 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 2361 if(__get_user(target_set.sig[i], &frame->sf_mask.sig[i])) 2362 goto badframe; 2363 } 2364 2365 target_to_host_sigset_internal(&blocked, &target_set); 2366 sigprocmask(SIG_SETMASK, &blocked, NULL); 2367 2368 if (restore_sigcontext(regs, &frame->sf_sc)) 2369 goto badframe; 2370 2371 #if 0 2372 /* 2373 * Don't let your children do this ... 2374 */ 2375 __asm__ __volatile__( 2376 "move\t$29, %0\n\t" 2377 "j\tsyscall_exit" 2378 :/* no outputs */ 2379 :"r" (®s)); 2380 /* Unreached */ 2381 #endif 2382 2383 regs->PC[regs->current_tc] = regs->CP0_EPC; 2384 /* I am not sure this is right, but it seems to work 2385 * maybe a problem with nested signals ? */ 2386 regs->CP0_EPC = 0; 2387 return 0; 2388 2389 badframe: 2390 force_sig(TARGET_SIGSEGV/*, current*/); 2391 return 0; 2392 } 2393 2394 static void setup_rt_frame(int sig, struct emulated_sigaction *ka, 2395 target_siginfo_t *info, 2396 target_sigset_t *set, CPUState *env) 2397 { 2398 fprintf(stderr, "setup_rt_frame: not implemented\n"); 2399 } 2400 2401 long do_rt_sigreturn(CPUState *env) 2402 { 2403 fprintf(stderr, "do_rt_sigreturn: not implemented\n"); 2404 return -TARGET_ENOSYS; 2405 } 2406 2407 #elif defined(TARGET_SH4) 2408 2409 /* 2410 * code and data structures from linux kernel: 2411 * include/asm-sh/sigcontext.h 2412 * arch/sh/kernel/signal.c 2413 */ 2414 2415 struct target_sigcontext { 2416 target_ulong oldmask; 2417 2418 /* CPU registers */ 2419 target_ulong sc_gregs[16]; 2420 target_ulong sc_pc; 2421 target_ulong sc_pr; 2422 target_ulong sc_sr; 2423 target_ulong sc_gbr; 2424 target_ulong sc_mach; 2425 target_ulong sc_macl; 2426 2427 /* FPU registers */ 2428 target_ulong sc_fpregs[16]; 2429 target_ulong sc_xfpregs[16]; 2430 unsigned int sc_fpscr; 2431 unsigned int sc_fpul; 2432 unsigned int sc_ownedfp; 2433 }; 2434 2435 struct target_sigframe 2436 { 2437 struct target_sigcontext sc; 2438 target_ulong extramask[TARGET_NSIG_WORDS-1]; 2439 uint16_t retcode[3]; 2440 }; 2441 2442 2443 struct target_ucontext { 2444 target_ulong uc_flags; 2445 struct target_ucontext *uc_link; 2446 target_stack_t uc_stack; 2447 struct target_sigcontext uc_mcontext; 2448 target_sigset_t uc_sigmask; /* mask last for extensibility */ 2449 }; 2450 2451 struct target_rt_sigframe 2452 { 2453 struct target_siginfo info; 2454 struct target_ucontext uc; 2455 uint16_t retcode[3]; 2456 }; 2457 2458 2459 #define MOVW(n) (0x9300|((n)-2)) /* Move mem word at PC+n to R3 */ 2460 #define TRAP_NOARG 0xc310 /* Syscall w/no args (NR in R3) SH3/4 */ 2461 2462 static abi_ulong get_sigframe(struct emulated_sigaction *ka, 2463 unsigned long sp, size_t frame_size) 2464 { 2465 if ((ka->sa.sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags(sp) == 0)) { 2466 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; 2467 } 2468 2469 return (sp - frame_size) & -8ul; 2470 } 2471 2472 static int setup_sigcontext(struct target_sigcontext *sc, 2473 CPUState *regs, unsigned long mask) 2474 { 2475 int err = 0; 2476 2477 #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x) 2478 COPY(gregs[0]); COPY(gregs[1]); 2479 COPY(gregs[2]); COPY(gregs[3]); 2480 COPY(gregs[4]); COPY(gregs[5]); 2481 COPY(gregs[6]); COPY(gregs[7]); 2482 COPY(gregs[8]); COPY(gregs[9]); 2483 COPY(gregs[10]); COPY(gregs[11]); 2484 COPY(gregs[12]); COPY(gregs[13]); 2485 COPY(gregs[14]); COPY(gregs[15]); 2486 COPY(gbr); COPY(mach); 2487 COPY(macl); COPY(pr); 2488 COPY(sr); COPY(pc); 2489 #undef COPY 2490 2491 /* todo: save FPU registers here */ 2492 2493 /* non-iBCS2 extensions.. */ 2494 err |= __put_user(mask, &sc->oldmask); 2495 2496 return err; 2497 } 2498 2499 static int restore_sigcontext(struct CPUState *regs, 2500 struct target_sigcontext *sc) 2501 { 2502 unsigned int err = 0; 2503 2504 #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x) 2505 COPY(gregs[1]); 2506 COPY(gregs[2]); COPY(gregs[3]); 2507 COPY(gregs[4]); COPY(gregs[5]); 2508 COPY(gregs[6]); COPY(gregs[7]); 2509 COPY(gregs[8]); COPY(gregs[9]); 2510 COPY(gregs[10]); COPY(gregs[11]); 2511 COPY(gregs[12]); COPY(gregs[13]); 2512 COPY(gregs[14]); COPY(gregs[15]); 2513 COPY(gbr); COPY(mach); 2514 COPY(macl); COPY(pr); 2515 COPY(sr); COPY(pc); 2516 #undef COPY 2517 2518 /* todo: restore FPU registers here */ 2519 2520 regs->tra = -1; /* disable syscall checks */ 2521 return err; 2522 } 2523 2524 static void setup_frame(int sig, struct emulated_sigaction *ka, 2525 target_sigset_t *set, CPUState *regs) 2526 { 2527 struct target_sigframe *frame; 2528 abi_ulong frame_addr; 2529 int i; 2530 int err = 0; 2531 int signal; 2532 2533 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame)); 2534 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 2535 goto give_sigsegv; 2536 2537 signal = current_exec_domain_sig(sig); 2538 2539 err |= setup_sigcontext(&frame->sc, regs, set->sig[0]); 2540 2541 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) { 2542 err |= __put_user(set->sig[i + 1], &frame->extramask[i]); 2543 } 2544 2545 /* Set up to return from userspace. If provided, use a stub 2546 already in userspace. */ 2547 if (ka->sa.sa_flags & TARGET_SA_RESTORER) { 2548 regs->pr = (unsigned long) ka->sa.sa_restorer; 2549 } else { 2550 /* Generate return code (system call to sigreturn) */ 2551 err |= __put_user(MOVW(2), &frame->retcode[0]); 2552 err |= __put_user(TRAP_NOARG, &frame->retcode[1]); 2553 err |= __put_user((TARGET_NR_sigreturn), &frame->retcode[2]); 2554 regs->pr = (unsigned long) frame->retcode; 2555 } 2556 2557 if (err) 2558 goto give_sigsegv; 2559 2560 /* Set up registers for signal handler */ 2561 regs->gregs[15] = (unsigned long) frame; 2562 regs->gregs[4] = signal; /* Arg for signal handler */ 2563 regs->gregs[5] = 0; 2564 regs->gregs[6] = (unsigned long) &frame->sc; 2565 regs->pc = (unsigned long) ka->sa._sa_handler; 2566 2567 unlock_user_struct(frame, frame_addr, 1); 2568 return; 2569 2570 give_sigsegv: 2571 unlock_user_struct(frame, frame_addr, 1); 2572 force_sig(SIGSEGV); 2573 } 2574 2575 static void setup_rt_frame(int sig, struct emulated_sigaction *ka, 2576 target_siginfo_t *info, 2577 target_sigset_t *set, CPUState *regs) 2578 { 2579 struct target_rt_sigframe *frame; 2580 abi_ulong frame_addr; 2581 int i; 2582 int err = 0; 2583 int signal; 2584 2585 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame)); 2586 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 2587 goto give_sigsegv; 2588 2589 signal = current_exec_domain_sig(sig); 2590 2591 err |= copy_siginfo_to_user(&frame->info, info); 2592 2593 /* Create the ucontext. */ 2594 err |= __put_user(0, &frame->uc.uc_flags); 2595 err |= __put_user(0, (unsigned long *)&frame->uc.uc_link); 2596 err |= __put_user((void *)target_sigaltstack_used.ss_sp, 2597 &frame->uc.uc_stack.ss_sp); 2598 err |= __put_user(sas_ss_flags(regs->gregs[15]), 2599 &frame->uc.uc_stack.ss_flags); 2600 err |= __put_user(target_sigaltstack_used.ss_size, 2601 &frame->uc.uc_stack.ss_size); 2602 err |= setup_sigcontext(&frame->uc.uc_mcontext, 2603 regs, set->sig[0]); 2604 for(i = 0; i < TARGET_NSIG_WORDS; i++) { 2605 err |= __put_user(set->sig[i], &frame->uc.uc_sigmask.sig[i]); 2606 } 2607 2608 /* Set up to return from userspace. If provided, use a stub 2609 already in userspace. */ 2610 if (ka->sa.sa_flags & TARGET_SA_RESTORER) { 2611 regs->pr = (unsigned long) ka->sa.sa_restorer; 2612 } else { 2613 /* Generate return code (system call to sigreturn) */ 2614 err |= __put_user(MOVW(2), &frame->retcode[0]); 2615 err |= __put_user(TRAP_NOARG, &frame->retcode[1]); 2616 err |= __put_user((TARGET_NR_rt_sigreturn), &frame->retcode[2]); 2617 regs->pr = (unsigned long) frame->retcode; 2618 } 2619 2620 if (err) 2621 goto give_sigsegv; 2622 2623 /* Set up registers for signal handler */ 2624 regs->gregs[15] = (unsigned long) frame; 2625 regs->gregs[4] = signal; /* Arg for signal handler */ 2626 regs->gregs[5] = (unsigned long) &frame->info; 2627 regs->gregs[6] = (unsigned long) &frame->uc; 2628 regs->pc = (unsigned long) ka->sa._sa_handler; 2629 2630 unlock_user_struct(frame, frame_addr, 1); 2631 return; 2632 2633 give_sigsegv: 2634 unlock_user_struct(frame, frame_addr, 1); 2635 force_sig(SIGSEGV); 2636 } 2637 2638 long do_sigreturn(CPUState *regs) 2639 { 2640 struct target_sigframe *frame; 2641 abi_ulong frame_addr; 2642 sigset_t blocked; 2643 target_sigset_t target_set; 2644 int i; 2645 int err = 0; 2646 2647 #if defined(DEBUG_SIGNAL) 2648 fprintf(stderr, "do_sigreturn\n"); 2649 #endif 2650 frame_addr = regs->gregs[15]; 2651 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 2652 goto badframe; 2653 2654 err |= __get_user(target_set.sig[0], &frame->sc.oldmask); 2655 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 2656 err |= (__get_user(target_set.sig[i], &frame->extramask[i - 1])); 2657 } 2658 2659 if (err) 2660 goto badframe; 2661 2662 target_to_host_sigset_internal(&blocked, &target_set); 2663 sigprocmask(SIG_SETMASK, &blocked, NULL); 2664 2665 if (restore_sigcontext(regs, &frame->sc)) 2666 goto badframe; 2667 2668 unlock_user_struct(frame, frame_addr, 0); 2669 return regs->gregs[0]; 2670 2671 badframe: 2672 unlock_user_struct(frame, frame_addr, 0); 2673 force_sig(TARGET_SIGSEGV); 2674 return 0; 2675 } 2676 2677 long do_rt_sigreturn(CPUState *regs) 2678 { 2679 struct target_rt_sigframe *frame; 2680 abi_ulong frame_addr; 2681 sigset_t blocked; 2682 2683 #if defined(DEBUG_SIGNAL) 2684 fprintf(stderr, "do_rt_sigreturn\n"); 2685 #endif 2686 frame_addr = regs->gregs[15]; 2687 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) 2688 goto badframe; 2689 2690 target_to_host_sigset(&blocked, &frame->uc.uc_sigmask); 2691 sigprocmask(SIG_SETMASK, &blocked, NULL); 2692 2693 if (restore_sigcontext(regs, &frame->uc.uc_mcontext)) 2694 goto badframe; 2695 2696 if (do_sigaltstack(frame_addr + 2697 offsetof(struct target_rt_sigframe, uc.uc_stack), 2698 0, get_sp_from_cpustate(regs)) == -EFAULT) 2699 goto badframe; 2700 2701 unlock_user_struct(frame, frame_addr, 0); 2702 return regs->gregs[0]; 2703 2704 badframe: 2705 unlock_user_struct(frame, frame_addr, 0); 2706 force_sig(TARGET_SIGSEGV); 2707 return 0; 2708 } 2709 #elif defined(TARGET_CRIS) 2710 2711 struct target_sigcontext { 2712 struct target_pt_regs regs; /* needs to be first */ 2713 uint32_t oldmask; 2714 uint32_t usp; /* usp before stacking this gunk on it */ 2715 }; 2716 2717 /* Signal frames. */ 2718 struct target_signal_frame { 2719 struct target_sigcontext sc; 2720 uint32_t extramask[TARGET_NSIG_WORDS - 1]; 2721 uint8_t retcode[8]; /* Trampoline code. */ 2722 }; 2723 2724 struct rt_signal_frame { 2725 struct siginfo *pinfo; 2726 void *puc; 2727 struct siginfo info; 2728 struct ucontext uc; 2729 uint8_t retcode[8]; /* Trampoline code. */ 2730 }; 2731 2732 static void setup_sigcontext(struct target_sigcontext *sc, CPUState *env) 2733 { 2734 __put_user(env->regs[0], &sc->regs.r0); 2735 __put_user(env->regs[1], &sc->regs.r1); 2736 __put_user(env->regs[2], &sc->regs.r2); 2737 __put_user(env->regs[3], &sc->regs.r3); 2738 __put_user(env->regs[4], &sc->regs.r4); 2739 __put_user(env->regs[5], &sc->regs.r5); 2740 __put_user(env->regs[6], &sc->regs.r6); 2741 __put_user(env->regs[7], &sc->regs.r7); 2742 __put_user(env->regs[8], &sc->regs.r8); 2743 __put_user(env->regs[9], &sc->regs.r9); 2744 __put_user(env->regs[10], &sc->regs.r10); 2745 __put_user(env->regs[11], &sc->regs.r11); 2746 __put_user(env->regs[12], &sc->regs.r12); 2747 __put_user(env->regs[13], &sc->regs.r13); 2748 __put_user(env->regs[14], &sc->usp); 2749 __put_user(env->regs[15], &sc->regs.acr); 2750 __put_user(env->pregs[PR_MOF], &sc->regs.mof); 2751 __put_user(env->pregs[PR_SRP], &sc->regs.srp); 2752 __put_user(env->pc, &sc->regs.erp); 2753 } 2754 2755 static void restore_sigcontext(struct target_sigcontext *sc, CPUState *env) 2756 { 2757 __get_user(env->regs[0], &sc->regs.r0); 2758 __get_user(env->regs[1], &sc->regs.r1); 2759 __get_user(env->regs[2], &sc->regs.r2); 2760 __get_user(env->regs[3], &sc->regs.r3); 2761 __get_user(env->regs[4], &sc->regs.r4); 2762 __get_user(env->regs[5], &sc->regs.r5); 2763 __get_user(env->regs[6], &sc->regs.r6); 2764 __get_user(env->regs[7], &sc->regs.r7); 2765 __get_user(env->regs[8], &sc->regs.r8); 2766 __get_user(env->regs[9], &sc->regs.r9); 2767 __get_user(env->regs[10], &sc->regs.r10); 2768 __get_user(env->regs[11], &sc->regs.r11); 2769 __get_user(env->regs[12], &sc->regs.r12); 2770 __get_user(env->regs[13], &sc->regs.r13); 2771 __get_user(env->regs[14], &sc->usp); 2772 __get_user(env->regs[15], &sc->regs.acr); 2773 __get_user(env->pregs[PR_MOF], &sc->regs.mof); 2774 __get_user(env->pregs[PR_SRP], &sc->regs.srp); 2775 __get_user(env->pc, &sc->regs.erp); 2776 } 2777 2778 static abi_ulong get_sigframe(CPUState *env, int framesize) 2779 { 2780 abi_ulong sp; 2781 /* Align the stack downwards to 4. */ 2782 sp = (env->regs[R_SP] & ~3); 2783 return sp - framesize; 2784 } 2785 2786 static void setup_frame(int sig, struct emulated_sigaction *ka, 2787 target_sigset_t *set, CPUState *env) 2788 { 2789 struct target_signal_frame *frame; 2790 abi_ulong frame_addr; 2791 int err = 0; 2792 int i; 2793 2794 frame_addr = get_sigframe(env, sizeof *frame); 2795 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) 2796 goto badframe; 2797 2798 /* 2799 * The CRIS signal return trampoline. A real linux/CRIS kernel doesn't 2800 * use this trampoline anymore but it sets it up for GDB. 2801 * In QEMU, using the trampoline simplifies things a bit so we use it. 2802 * 2803 * This is movu.w __NR_sigreturn, r9; break 13; 2804 */ 2805 err |= __put_user(0x9c5f, frame->retcode+0); 2806 err |= __put_user(TARGET_NR_sigreturn, 2807 frame->retcode+2); 2808 err |= __put_user(0xe93d, frame->retcode+4); 2809 2810 /* Save the mask. */ 2811 err |= __put_user(set->sig[0], &frame->sc.oldmask); 2812 if (err) 2813 goto badframe; 2814 2815 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 2816 if (__put_user(set->sig[i], &frame->extramask[i - 1])) 2817 goto badframe; 2818 } 2819 2820 setup_sigcontext(&frame->sc, env); 2821 2822 /* Move the stack and setup the arguments for the handler. */ 2823 env->regs[R_SP] = (uint32_t) frame; 2824 env->regs[10] = sig; 2825 env->pc = (unsigned long) ka->sa._sa_handler; 2826 /* Link SRP so the guest returns through the trampoline. */ 2827 env->pregs[PR_SRP] = (uint32_t) &frame->retcode[0]; 2828 2829 unlock_user_struct(frame, frame_addr, 1); 2830 return; 2831 badframe: 2832 unlock_user_struct(frame, frame_addr, 1); 2833 force_sig(TARGET_SIGSEGV); 2834 } 2835 2836 static void setup_rt_frame(int sig, struct emulated_sigaction *ka, 2837 target_siginfo_t *info, 2838 target_sigset_t *set, CPUState *env) 2839 { 2840 fprintf(stderr, "CRIS setup_rt_frame: not implemented\n"); 2841 } 2842 2843 long do_sigreturn(CPUState *env) 2844 { 2845 struct target_signal_frame *frame; 2846 abi_ulong frame_addr; 2847 target_sigset_t target_set; 2848 sigset_t set; 2849 int i; 2850 2851 frame_addr = env->regs[R_SP]; 2852 /* Make sure the guest isn't playing games. */ 2853 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1)) 2854 goto badframe; 2855 2856 /* Restore blocked signals */ 2857 if (__get_user(target_set.sig[0], &frame->sc.oldmask)) 2858 goto badframe; 2859 for(i = 1; i < TARGET_NSIG_WORDS; i++) { 2860 if (__get_user(target_set.sig[i], &frame->extramask[i - 1])) 2861 goto badframe; 2862 } 2863 target_to_host_sigset_internal(&set, &target_set); 2864 sigprocmask(SIG_SETMASK, &set, NULL); 2865 2866 restore_sigcontext(&frame->sc, env); 2867 /* Compensate for the syscall return path advancing brk. */ 2868 env->pc -= 2; 2869 2870 unlock_user_struct(frame, frame_addr, 0); 2871 return env->regs[10]; 2872 badframe: 2873 unlock_user_struct(frame, frame_addr, 0); 2874 force_sig(TARGET_SIGSEGV); 2875 } 2876 2877 long do_rt_sigreturn(CPUState *env) 2878 { 2879 fprintf(stderr, "CRIS do_rt_sigreturn: not implemented\n"); 2880 return -TARGET_ENOSYS; 2881 } 2882 2883 #else 2884 2885 static void setup_frame(int sig, struct emulated_sigaction *ka, 2886 target_sigset_t *set, CPUState *env) 2887 { 2888 fprintf(stderr, "setup_frame: not implemented\n"); 2889 } 2890 2891 static void setup_rt_frame(int sig, struct emulated_sigaction *ka, 2892 target_siginfo_t *info, 2893 target_sigset_t *set, CPUState *env) 2894 { 2895 fprintf(stderr, "setup_rt_frame: not implemented\n"); 2896 } 2897 2898 long do_sigreturn(CPUState *env) 2899 { 2900 fprintf(stderr, "do_sigreturn: not implemented\n"); 2901 return -TARGET_ENOSYS; 2902 } 2903 2904 long do_rt_sigreturn(CPUState *env) 2905 { 2906 fprintf(stderr, "do_rt_sigreturn: not implemented\n"); 2907 return -TARGET_ENOSYS; 2908 } 2909 2910 #endif 2911 2912 void process_pending_signals(void *cpu_env) 2913 { 2914 int sig; 2915 abi_ulong handler; 2916 sigset_t set, old_set; 2917 target_sigset_t target_old_set; 2918 struct emulated_sigaction *k; 2919 struct sigqueue *q; 2920 2921 if (!signal_pending) 2922 return; 2923 2924 k = sigact_table; 2925 for(sig = 1; sig <= TARGET_NSIG; sig++) { 2926 if (k->pending) 2927 goto handle_signal; 2928 k++; 2929 } 2930 /* if no signal is pending, just return */ 2931 signal_pending = 0; 2932 return; 2933 2934 handle_signal: 2935 #ifdef DEBUG_SIGNAL 2936 fprintf(stderr, "qemu: process signal %d\n", sig); 2937 #endif 2938 /* dequeue signal */ 2939 q = k->first; 2940 k->first = q->next; 2941 if (!k->first) 2942 k->pending = 0; 2943 2944 sig = gdb_handlesig (cpu_env, sig); 2945 if (!sig) { 2946 fprintf (stderr, "Lost signal\n"); 2947 abort(); 2948 } 2949 2950 handler = k->sa._sa_handler; 2951 if (handler == TARGET_SIG_DFL) { 2952 /* default handler : ignore some signal. The other are fatal */ 2953 if (sig != TARGET_SIGCHLD && 2954 sig != TARGET_SIGURG && 2955 sig != TARGET_SIGWINCH) { 2956 force_sig(sig); 2957 } 2958 } else if (handler == TARGET_SIG_IGN) { 2959 /* ignore sig */ 2960 } else if (handler == TARGET_SIG_ERR) { 2961 force_sig(sig); 2962 } else { 2963 /* compute the blocked signals during the handler execution */ 2964 target_to_host_sigset(&set, &k->sa.sa_mask); 2965 /* SA_NODEFER indicates that the current signal should not be 2966 blocked during the handler */ 2967 if (!(k->sa.sa_flags & TARGET_SA_NODEFER)) 2968 sigaddset(&set, target_to_host_signal(sig)); 2969 2970 /* block signals in the handler using Linux */ 2971 sigprocmask(SIG_BLOCK, &set, &old_set); 2972 /* save the previous blocked signal state to restore it at the 2973 end of the signal execution (see do_sigreturn) */ 2974 host_to_target_sigset_internal(&target_old_set, &old_set); 2975 2976 /* if the CPU is in VM86 mode, we restore the 32 bit values */ 2977 #if defined(TARGET_I386) && !defined(TARGET_X86_64) 2978 { 2979 CPUX86State *env = cpu_env; 2980 if (env->eflags & VM_MASK) 2981 save_v86_state(env); 2982 } 2983 #endif 2984 /* prepare the stack frame of the virtual CPU */ 2985 if (k->sa.sa_flags & TARGET_SA_SIGINFO) 2986 setup_rt_frame(sig, k, &q->info, &target_old_set, cpu_env); 2987 else 2988 setup_frame(sig, k, &target_old_set, cpu_env); 2989 if (k->sa.sa_flags & TARGET_SA_RESETHAND) 2990 k->sa._sa_handler = TARGET_SIG_DFL; 2991 } 2992 if (q != &k->info) 2993 free_sigqueue(q); 2994 } 2995