linux-user/signal.c

   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 #ifdef __ia64__
  30 #undef uc_mcontext
  31 #undef uc_sigmask
  32 #undef uc_stack
  33 #undef uc_link
  34 #endif
  35
  36 #include "qemu.h"
  37
  38 //#define DEBUG_SIGNAL
  39
  40 #define MAX_SIGQUEUE_SIZE 1024
  41
  42 struct sigqueue {
  43     struct sigqueue *next;
  44     target_siginfo_t info;
  45 };
  46
  47 struct emulated_sigaction {
  48     struct target_sigaction sa;
  49     int pending; /* true if signal is pending */
  50     struct sigqueue *first;
  51     struct sigqueue info; /* in order to always have memory for the
  52                              first signal, we put it here */
  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 host_to_target_signal(int sig)
 103 {
 104     return host_to_target_signal_table[sig];
 105 }
 106
 107 static inline int target_to_host_signal(int sig)
 108 {
 109     return target_to_host_signal_table[sig];
 110 }
 111
 112 static void host_to_target_sigset_internal(target_sigset_t *d,
 113                                            const sigset_t *s)
 114 {
 115     int i;
 116     unsigned long sigmask;
 117     uint32_t target_sigmask;
 118
 119     sigmask = ((unsigned long *)s)[0];
 120     target_sigmask = 0;
 121     for(i = 0; i < 32; i++) {
 122         if (sigmask & (1 << i))
 123             target_sigmask |= 1 << (host_to_target_signal(i + 1) - 1);
 124     }
 125 #if TARGET_LONG_BITS == 32 && HOST_LONG_BITS == 32
 126     d->sig[0] = target_sigmask;
 127     for(i = 1;i < TARGET_NSIG_WORDS; i++) {
 128         d->sig[i] = ((unsigned long *)s)[i];
 129     }
 130 #elif TARGET_LONG_BITS == 32 && HOST_LONG_BITS == 64 && TARGET_NSIG_WORDS == 2
 131     d->sig[0] = target_sigmask;
 132     d->sig[1] = sigmask >> 32;
 133 #else
 134 #error host_to_target_sigset
 135 #endif
 136 }
 137
 138 void host_to_target_sigset(target_sigset_t *d, const sigset_t *s)
 139 {
 140     target_sigset_t d1;
 141     int i;
 142
 143     host_to_target_sigset_internal(&d1, s);
 144     for(i = 0;i < TARGET_NSIG_WORDS; i++)
 145         __put_user(d1.sig[i], &d->sig[i]);
 146 }
 147
 148 void target_to_host_sigset_internal(sigset_t *d, const target_sigset_t *s)
 149 {
 150     int i;
 151     unsigned long sigmask;
 152     target_ulong target_sigmask;
 153
 154     target_sigmask = s->sig[0];
 155     sigmask = 0;
 156     for(i = 0; i < 32; i++) {
 157         if (target_sigmask & (1 << i))
 158             sigmask |= 1 << (target_to_host_signal(i + 1) - 1);
 159     }
 160 #if TARGET_LONG_BITS == 32 && HOST_LONG_BITS == 32
 161     ((unsigned long *)d)[0] = sigmask;
 162     for(i = 1;i < TARGET_NSIG_WORDS; i++) {
 163         ((unsigned long *)d)[i] = s->sig[i];
 164     }
 165 #elif TARGET_LONG_BITS == 32 && HOST_LONG_BITS == 64 && TARGET_NSIG_WORDS == 2
 166     ((unsigned long *)d)[0] = sigmask | ((unsigned long)(s->sig[1]) << 32);
 167 #else
 168 #error target_to_host_sigset
 169 #endif /* TARGET_LONG_BITS */
 170 }
 171
 172 void target_to_host_sigset(sigset_t *d, const target_sigset_t *s)
 173 {
 174     target_sigset_t s1;
 175     int i;
 176
 177     for(i = 0;i < TARGET_NSIG_WORDS; i++)
 178         __get_user(s1.sig[i], &s->sig[i]);
 179     target_to_host_sigset_internal(d, &s1);
 180 }
 181
 182 void host_to_target_old_sigset(target_ulong *old_sigset,
 183                                const sigset_t *sigset)
 184 {
 185     target_sigset_t d;
 186     host_to_target_sigset(&d, sigset);
 187     *old_sigset = d.sig[0];
 188 }
 189
 190 void target_to_host_old_sigset(sigset_t *sigset,
 191                                const target_ulong *old_sigset)
 192 {
 193     target_sigset_t d;
 194     int i;
 195
 196     d.sig[0] = *old_sigset;
 197     for(i = 1;i < TARGET_NSIG_WORDS; i++)
 198         d.sig[i] = 0;
 199     target_to_host_sigset(sigset, &d);
 200 }
 201
 202 /* siginfo conversion */
 203
 204 static inline void host_to_target_siginfo_noswap(target_siginfo_t *tinfo,
 205                                                  const siginfo_t *info)
 206 {
 207     int sig;
 208     sig = host_to_target_signal(info->si_signo);
 209     tinfo->si_signo = sig;
 210     tinfo->si_errno = 0;
 211     tinfo->si_code = 0;
 212     if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV ||
 213         sig == SIGBUS || sig == SIGTRAP) {
 214         /* should never come here, but who knows. The information for
 215            the target is irrelevant */
 216         tinfo->_sifields._sigfault._addr = 0;
 217     } else if (sig >= TARGET_SIGRTMIN) {
 218         tinfo->_sifields._rt._pid = info->si_pid;
 219         tinfo->_sifields._rt._uid = info->si_uid;
 220         /* XXX: potential problem if 64 bit */
 221         tinfo->_sifields._rt._sigval.sival_ptr =
 222             (target_ulong)info->si_value.sival_ptr;
 223     }
 224 }
 225
 226 static void tswap_siginfo(target_siginfo_t *tinfo,
 227                           const target_siginfo_t *info)
 228 {
 229     int sig;
 230     sig = info->si_signo;
 231     tinfo->si_signo = tswap32(sig);
 232     tinfo->si_errno = tswap32(info->si_errno);
 233     tinfo->si_code = tswap32(info->si_code);
 234     if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV ||
 235         sig == SIGBUS || sig == SIGTRAP) {
 236         tinfo->_sifields._sigfault._addr =
 237             tswapl(info->_sifields._sigfault._addr);
 238     } else if (sig >= TARGET_SIGRTMIN) {
 239         tinfo->_sifields._rt._pid = tswap32(info->_sifields._rt._pid);
 240         tinfo->_sifields._rt._uid = tswap32(info->_sifields._rt._uid);
 241         tinfo->_sifields._rt._sigval.sival_ptr =
 242             tswapl(info->_sifields._rt._sigval.sival_ptr);
 243     }
 244 }
 245
 246
 247 void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info)
 248 {
 249     host_to_target_siginfo_noswap(tinfo, info);
 250     tswap_siginfo(tinfo, tinfo);
 251 }
 252
 253 /* XXX: we support only POSIX RT signals are used. */
 254 /* XXX: find a solution for 64 bit (additionnal malloced data is needed) */
 255 void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo)
 256 {
 257     info->si_signo = tswap32(tinfo->si_signo);
 258     info->si_errno = tswap32(tinfo->si_errno);
 259     info->si_code = tswap32(tinfo->si_code);
 260     info->si_pid = tswap32(tinfo->_sifields._rt._pid);
 261     info->si_uid = tswap32(tinfo->_sifields._rt._uid);
 262     info->si_value.sival_ptr =
 263         (void *)tswapl(tinfo->_sifields._rt._sigval.sival_ptr);
 264 }
 265
 266 void signal_init(void)
 267 {
 268     struct sigaction act;
 269     int i, j;
 270
 271     /* generate signal conversion tables */
 272     for(i = 1; i <= 64; i++) {
 273         if (host_to_target_signal_table[i] == 0)
 274             host_to_target_signal_table[i] = i;
 275     }
 276     for(i = 1; i <= 64; i++) {
 277         j = host_to_target_signal_table[i];
 278         target_to_host_signal_table[j] = i;
 279     }
 280
 281     /* set all host signal handlers. ALL signals are blocked during
 282        the handlers to serialize them. */
 283     sigfillset(&act.sa_mask);
 284     act.sa_flags = SA_SIGINFO;
 285     act.sa_sigaction = host_signal_handler;
 286     for(i = 1; i < NSIG; i++) {
 287         sigaction(i, &act, NULL);
 288     }
 289
 290     memset(sigact_table, 0, sizeof(sigact_table));
 291
 292     first_free = &sigqueue_table[0];
 293     for(i = 0; i < MAX_SIGQUEUE_SIZE - 1; i++)
 294         sigqueue_table[i].next = &sigqueue_table[i + 1];
 295     sigqueue_table[MAX_SIGQUEUE_SIZE - 1].next = NULL;
 296 }
 297
 298 /* signal queue handling */
 299
 300 static inline struct sigqueue *alloc_sigqueue(void)
 301 {
 302     struct sigqueue *q = first_free;
 303     if (!q)
 304         return NULL;
 305     first_free = q->next;
 306     return q;
 307 }
 308
 309 static inline void free_sigqueue(struct sigqueue *q)
 310 {
 311     q->next = first_free;
 312     first_free = q;
 313 }
 314
 315 /* abort execution with signal */
 316 void __attribute((noreturn)) force_sig(int sig)
 317 {
 318     int host_sig;
 319     host_sig = target_to_host_signal(sig);
 320     fprintf(stderr, "qemu: uncaught target signal %d (%s) - exiting\n",
 321             sig, strsignal(host_sig));
 322 #if 1
 323     _exit(-host_sig);
 324 #else
 325     {
 326         struct sigaction act;
 327         sigemptyset(&act.sa_mask);
 328         act.sa_flags = SA_SIGINFO;
 329         act.sa_sigaction = SIG_DFL;
 330         sigaction(SIGABRT, &act, NULL);
 331         abort();
 332     }
 333 #endif
 334 }
 335
 336 /* queue a signal so that it will be send to the virtual CPU as soon
 337    as possible */
 338 int queue_signal(int sig, target_siginfo_t *info)
 339 {
 340     struct emulated_sigaction *k;
 341     struct sigqueue *q, **pq;
 342     target_ulong handler;
 343
 344 #if defined(DEBUG_SIGNAL)
 345     fprintf(stderr, "queue_signal: sig=%d\n",
 346             sig);
 347 #endif
 348     k = &sigact_table[sig - 1];
 349     handler = k->sa._sa_handler;
 350     if (handler == TARGET_SIG_DFL) {
 351         /* default handler : ignore some signal. The other are fatal */
 352         if (sig != TARGET_SIGCHLD &&
 353             sig != TARGET_SIGURG &&
 354             sig != TARGET_SIGWINCH) {
 355             force_sig(sig);
 356         } else {
 357             return 0; /* indicate ignored */
 358         }
 359     } else if (handler == TARGET_SIG_IGN) {
 360         /* ignore signal */
 361         return 0;
 362     } else if (handler == TARGET_SIG_ERR) {
 363         force_sig(sig);
 364     } else {
 365         pq = &k->first;
 366         if (sig < TARGET_SIGRTMIN) {
 367             /* if non real time signal, we queue exactly one signal */
 368             if (!k->pending)
 369                 q = &k->info;
 370             else
 371                 return 0;
 372         } else {
 373             if (!k->pending) {
 374                 /* first signal */
 375                 q = &k->info;
 376             } else {
 377                 q = alloc_sigqueue();
 378                 if (!q)
 379                     return -EAGAIN;
 380                 while (*pq != NULL)
 381                     pq = &(*pq)->next;
 382             }
 383         }
 384         *pq = q;
 385         q->info = *info;
 386         q->next = NULL;
 387         k->pending = 1;
 388         /* signal that a new signal is pending */
 389         signal_pending = 1;
 390         return 1; /* indicates that the signal was queued */
 391     }
 392 }
 393
 394 static void host_signal_handler(int host_signum, siginfo_t *info,
 395                                 void *puc)
 396 {
 397     int sig;
 398     target_siginfo_t tinfo;
 399
 400     /* the CPU emulator uses some host signals to detect exceptions,
 401        we we forward to it some signals */
 402     if (host_signum == SIGSEGV || host_signum == SIGBUS
 403 #if defined(TARGET_I386) && defined(USE_CODE_COPY)
 404         || host_signum == SIGFPE
 405 #endif
 406         ) {
 407         if (cpu_signal_handler(host_signum, info, puc))
 408             return;
 409     }
 410
 411     /* get target signal number */
 412     sig = host_to_target_signal(host_signum);
 413     if (sig < 1 || sig > TARGET_NSIG)
 414         return;
 415 #if defined(DEBUG_SIGNAL)
 416     fprintf(stderr, "qemu: got signal %d\n", sig);
 417 #endif
 418     host_to_target_siginfo_noswap(&tinfo, info);
 419     if (queue_signal(sig, &tinfo) == 1) {
 420         /* interrupt the virtual CPU as soon as possible */
 421         cpu_interrupt(global_env, CPU_INTERRUPT_EXIT);
 422     }
 423 }
 424
 425 int do_sigaction(int sig, const struct target_sigaction *act,
 426                  struct target_sigaction *oact)
 427 {
 428     struct emulated_sigaction *k;
 429     struct sigaction act1;
 430     int host_sig;
 431
 432     if (sig < 1 || sig > TARGET_NSIG)
 433         return -EINVAL;
 434     k = &sigact_table[sig - 1];
 435 #if defined(DEBUG_SIGNAL)
 436     fprintf(stderr, "sigaction sig=%d act=0x%08x, oact=0x%08x\n",
 437             sig, (int)act, (int)oact);
 438 #endif
 439     if (oact) {
 440         oact->_sa_handler = tswapl(k->sa._sa_handler);
 441         oact->sa_flags = tswapl(k->sa.sa_flags);
 442         oact->sa_restorer = tswapl(k->sa.sa_restorer);
 443         oact->sa_mask = k->sa.sa_mask;
 444     }
 445     if (act) {
 446         k->sa._sa_handler = tswapl(act->_sa_handler);
 447         k->sa.sa_flags = tswapl(act->sa_flags);
 448         k->sa.sa_restorer = tswapl(act->sa_restorer);
 449         k->sa.sa_mask = act->sa_mask;
 450
 451         /* we update the host linux signal state */
 452         host_sig = target_to_host_signal(sig);
 453         if (host_sig != SIGSEGV && host_sig != SIGBUS) {
 454             sigfillset(&act1.sa_mask);
 455             act1.sa_flags = SA_SIGINFO;
 456             if (k->sa.sa_flags & TARGET_SA_RESTART)
 457                 act1.sa_flags |= SA_RESTART;
 458             /* NOTE: it is important to update the host kernel signal
 459                ignore state to avoid getting unexpected interrupted
 460                syscalls */
 461             if (k->sa._sa_handler == TARGET_SIG_IGN) {
 462                 act1.sa_sigaction = (void *)SIG_IGN;
 463             } else if (k->sa._sa_handler == TARGET_SIG_DFL) {
 464                 act1.sa_sigaction = (void *)SIG_DFL;
 465             } else {
 466                 act1.sa_sigaction = host_signal_handler;
 467             }
 468             sigaction(host_sig, &act1, NULL);
 469         }
 470     }
 471     return 0;
 472 }
 473
 474 #ifndef offsetof
 475 #define offsetof(type, field) ((size_t) &((type *)0)->field)
 476 #endif
 477
 478 static inline int copy_siginfo_to_user(target_siginfo_t *tinfo,
 479                                        const target_siginfo_t *info)
 480 {
 481     tswap_siginfo(tinfo, info);
 482     return 0;
 483 }
 484
 485 #ifdef TARGET_I386
 486
 487 /* from the Linux kernel */
 488
 489 struct target_fpreg {
 490         uint16_t significand[4];
 491         uint16_t exponent;
 492 };
 493
 494 struct target_fpxreg {
 495         uint16_t significand[4];
 496         uint16_t exponent;
 497         uint16_t padding[3];
 498 };
 499
 500 struct target_xmmreg {
 501         target_ulong element[4];
 502 };
 503
 504 struct target_fpstate {
 505         /* Regular FPU environment */
 506         target_ulong    cw;
 507         target_ulong    sw;
 508         target_ulong    tag;
 509         target_ulong    ipoff;
 510         target_ulong    cssel;
 511         target_ulong    dataoff;
 512         target_ulong    datasel;
 513         struct target_fpreg     _st[8];
 514         uint16_t        status;
 515         uint16_t        magic;          /* 0xffff = regular FPU data only */
 516
 517         /* FXSR FPU environment */
 518         target_ulong    _fxsr_env[6];   /* FXSR FPU env is ignored */
 519         target_ulong    mxcsr;
 520         target_ulong    reserved;
 521         struct target_fpxreg    _fxsr_st[8];    /* FXSR FPU reg data is ignored */
 522         struct target_xmmreg    _xmm[8];
 523         target_ulong    padding[56];
 524 };
 525
 526 #define X86_FXSR_MAGIC          0x0000
 527
 528 struct target_sigcontext {
 529         uint16_t gs, __gsh;
 530         uint16_t fs, __fsh;
 531         uint16_t es, __esh;
 532         uint16_t ds, __dsh;
 533         target_ulong edi;
 534         target_ulong esi;
 535         target_ulong ebp;
 536         target_ulong esp;
 537         target_ulong ebx;
 538         target_ulong edx;
 539         target_ulong ecx;
 540         target_ulong eax;
 541         target_ulong trapno;
 542         target_ulong err;
 543         target_ulong eip;
 544         uint16_t cs, __csh;
 545         target_ulong eflags;
 546         target_ulong esp_at_signal;
 547         uint16_t ss, __ssh;
 548         target_ulong fpstate; /* pointer */
 549         target_ulong oldmask;
 550         target_ulong cr2;
 551 };
 552
 553 typedef struct target_sigaltstack {
 554         target_ulong ss_sp;
 555         int ss_flags;
 556         target_ulong ss_size;
 557 } target_stack_t;
 558
 559 struct target_ucontext {
 560         target_ulong      uc_flags;
 561         target_ulong      uc_link;
 562         target_stack_t    uc_stack;
 563         struct target_sigcontext uc_mcontext;
 564         target_sigset_t   uc_sigmask;   /* mask last for extensibility */
 565 };
 566
 567 struct sigframe
 568 {
 569     target_ulong pretcode;
 570     int sig;
 571     struct target_sigcontext sc;
 572     struct target_fpstate fpstate;
 573     target_ulong extramask[TARGET_NSIG_WORDS-1];
 574     char retcode[8];
 575 };
 576
 577 struct rt_sigframe
 578 {
 579     target_ulong pretcode;
 580     int sig;
 581     target_ulong pinfo;
 582     target_ulong puc;
 583     struct target_siginfo info;
 584     struct target_ucontext uc;
 585     struct target_fpstate fpstate;
 586     char retcode[8];
 587 };
 588
 589 /*
 590  * Set up a signal frame.
 591  */
 592
 593 /* XXX: save x87 state */
 594 static int
 595 setup_sigcontext(struct target_sigcontext *sc, struct target_fpstate *fpstate,
 596                  CPUX86State *env, unsigned long mask)
 597 {
 598         int err = 0;
 599
 600         err |= __put_user(env->segs[R_GS].selector, (unsigned int *)&sc->gs);
 601         err |= __put_user(env->segs[R_FS].selector, (unsigned int *)&sc->fs);
 602         err |= __put_user(env->segs[R_ES].selector, (unsigned int *)&sc->es);
 603         err |= __put_user(env->segs[R_DS].selector, (unsigned int *)&sc->ds);
 604         err |= __put_user(env->regs[R_EDI], &sc->edi);
 605         err |= __put_user(env->regs[R_ESI], &sc->esi);
 606         err |= __put_user(env->regs[R_EBP], &sc->ebp);
 607         err |= __put_user(env->regs[R_ESP], &sc->esp);
 608         err |= __put_user(env->regs[R_EBX], &sc->ebx);
 609         err |= __put_user(env->regs[R_EDX], &sc->edx);
 610         err |= __put_user(env->regs[R_ECX], &sc->ecx);
 611         err |= __put_user(env->regs[R_EAX], &sc->eax);
 612         err |= __put_user(env->exception_index, &sc->trapno);
 613         err |= __put_user(env->error_code, &sc->err);
 614         err |= __put_user(env->eip, &sc->eip);
 615         err |= __put_user(env->segs[R_CS].selector, (unsigned int *)&sc->cs);
 616         err |= __put_user(env->eflags, &sc->eflags);
 617         err |= __put_user(env->regs[R_ESP], &sc->esp_at_signal);
 618         err |= __put_user(env->segs[R_SS].selector, (unsigned int *)&sc->ss);
 619
 620         cpu_x86_fsave(env, (void *)fpstate, 1);
 621         fpstate->status = fpstate->sw;
 622         err |= __put_user(0xffff, &fpstate->magic);
 623         err |= __put_user(fpstate, &sc->fpstate);
 624
 625         /* non-iBCS2 extensions.. */
 626         err |= __put_user(mask, &sc->oldmask);
 627         err |= __put_user(env->cr[2], &sc->cr2);
 628         return err;
 629 }
 630
 631 /*
 632  * Determine which stack to use..
 633  */
 634
 635 static inline void *
 636 get_sigframe(struct emulated_sigaction *ka, CPUX86State *env, size_t frame_size)
 637 {
 638         unsigned long esp;
 639
 640         /* Default to using normal stack */
 641         esp = env->regs[R_ESP];
 642 #if 0
 643         /* This is the X/Open sanctioned signal stack switching.  */
 644         if (ka->sa.sa_flags & SA_ONSTACK) {
 645                 if (sas_ss_flags(esp) == 0)
 646                         esp = current->sas_ss_sp + current->sas_ss_size;
 647         }
 648
 649         /* This is the legacy signal stack switching. */
 650         else
 651 #endif
 652         if ((env->segs[R_SS].selector & 0xffff) != __USER_DS &&
 653             !(ka->sa.sa_flags & TARGET_SA_RESTORER) &&
 654             ka->sa.sa_restorer) {
 655             esp = (unsigned long) ka->sa.sa_restorer;
 656         }
 657         return (void *)((esp - frame_size) & -8ul);
 658 }
 659
 660 static void setup_frame(int sig, struct emulated_sigaction *ka,
 661                         target_sigset_t *set, CPUX86State *env)
 662 {
 663         struct sigframe *frame;
 664         int i, err = 0;
 665
 666         frame = get_sigframe(ka, env, sizeof(*frame));
 667
 668         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 669                 goto give_sigsegv;
 670         err |= __put_user((/*current->exec_domain
 671                            && current->exec_domain->signal_invmap
 672                            && sig < 32
 673                            ? current->exec_domain->signal_invmap[sig]
 674                            : */ sig),
 675                           &frame->sig);
 676         if (err)
 677                 goto give_sigsegv;
 678
 679         setup_sigcontext(&frame->sc, &frame->fpstate, env, set->sig[0]);
 680         if (err)
 681                 goto give_sigsegv;
 682
 683         for(i = 1; i < TARGET_NSIG_WORDS; i++) {
 684             if (__put_user(set->sig[i], &frame->extramask[i - 1]))
 685                 goto give_sigsegv;
 686         }
 687
 688         /* Set up to return from userspace.  If provided, use a stub
 689            already in userspace.  */
 690         if (ka->sa.sa_flags & TARGET_SA_RESTORER) {
 691                 err |= __put_user(ka->sa.sa_restorer, &frame->pretcode);
 692         } else {
 693                 err |= __put_user(frame->retcode, &frame->pretcode);
 694                 /* This is popl %eax ; movl $,%eax ; int $0x80 */
 695                 err |= __put_user(0xb858, (short *)(frame->retcode+0));
 696                 err |= __put_user(TARGET_NR_sigreturn, (int *)(frame->retcode+2));
 697                 err |= __put_user(0x80cd, (short *)(frame->retcode+6));
 698         }
 699
 700         if (err)
 701                 goto give_sigsegv;
 702
 703         /* Set up registers for signal handler */
 704         env->regs[R_ESP] = (unsigned long) frame;
 705         env->eip = (unsigned long) ka->sa._sa_handler;
 706
 707         cpu_x86_load_seg(env, R_DS, __USER_DS);
 708         cpu_x86_load_seg(env, R_ES, __USER_DS);
 709         cpu_x86_load_seg(env, R_SS, __USER_DS);
 710         cpu_x86_load_seg(env, R_CS, __USER_CS);
 711         env->eflags &= ~TF_MASK;
 712
 713         return;
 714
 715 give_sigsegv:
 716         if (sig == TARGET_SIGSEGV)
 717                 ka->sa._sa_handler = TARGET_SIG_DFL;
 718         force_sig(TARGET_SIGSEGV /* , current */);
 719 }
 720
 721 static void setup_rt_frame(int sig, struct emulated_sigaction *ka,
 722                            target_siginfo_t *info,
 723                            target_sigset_t *set, CPUX86State *env)
 724 {
 725         struct rt_sigframe *frame;
 726         int i, err = 0;
 727
 728         frame = get_sigframe(ka, env, sizeof(*frame));
 729
 730         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 731                 goto give_sigsegv;
 732
 733         err |= __put_user((/*current->exec_domain
 734                            && current->exec_domain->signal_invmap
 735                            && sig < 32
 736                            ? current->exec_domain->signal_invmap[sig]
 737                            : */sig),
 738                           &frame->sig);
 739         err |= __put_user((target_ulong)&frame->info, &frame->pinfo);
 740         err |= __put_user((target_ulong)&frame->uc, &frame->puc);
 741         err |= copy_siginfo_to_user(&frame->info, info);
 742         if (err)
 743                 goto give_sigsegv;
 744
 745         /* Create the ucontext.  */
 746         err |= __put_user(0, &frame->uc.uc_flags);
 747         err |= __put_user(0, &frame->uc.uc_link);
 748         err |= __put_user(/*current->sas_ss_sp*/ 0, &frame->uc.uc_stack.ss_sp);
 749         err |= __put_user(/* sas_ss_flags(regs->esp) */ 0,
 750                           &frame->uc.uc_stack.ss_flags);
 751         err |= __put_user(/* current->sas_ss_size */ 0, &frame->uc.uc_stack.ss_size);
 752         err |= setup_sigcontext(&frame->uc.uc_mcontext, &frame->fpstate,
 753                                 env, set->sig[0]);
 754         for(i = 0; i < TARGET_NSIG_WORDS; i++) {
 755             if (__put_user(set->sig[i], &frame->uc.uc_sigmask.sig[i]))
 756                 goto give_sigsegv;
 757         }
 758
 759         /* Set up to return from userspace.  If provided, use a stub
 760            already in userspace.  */
 761         if (ka->sa.sa_flags & TARGET_SA_RESTORER) {
 762                 err |= __put_user(ka->sa.sa_restorer, &frame->pretcode);
 763         } else {
 764                 err |= __put_user(frame->retcode, &frame->pretcode);
 765                 /* This is movl $,%eax ; int $0x80 */
 766                 err |= __put_user(0xb8, (char *)(frame->retcode+0));
 767                 err |= __put_user(TARGET_NR_rt_sigreturn, (int *)(frame->retcode+1));
 768                 err |= __put_user(0x80cd, (short *)(frame->retcode+5));
 769         }
 770
 771         if (err)
 772                 goto give_sigsegv;
 773
 774         /* Set up registers for signal handler */
 775         env->regs[R_ESP] = (unsigned long) frame;
 776         env->eip = (unsigned long) ka->sa._sa_handler;
 777
 778         cpu_x86_load_seg(env, R_DS, __USER_DS);
 779         cpu_x86_load_seg(env, R_ES, __USER_DS);
 780         cpu_x86_load_seg(env, R_SS, __USER_DS);
 781         cpu_x86_load_seg(env, R_CS, __USER_CS);
 782         env->eflags &= ~TF_MASK;
 783
 784         return;
 785
 786 give_sigsegv:
 787         if (sig == TARGET_SIGSEGV)
 788                 ka->sa._sa_handler = TARGET_SIG_DFL;
 789         force_sig(TARGET_SIGSEGV /* , current */);
 790 }
 791
 792 static int
 793 restore_sigcontext(CPUX86State *env, struct target_sigcontext *sc, int *peax)
 794 {
 795         unsigned int err = 0;
 796
 797         cpu_x86_load_seg(env, R_GS, lduw(&sc->gs));
 798         cpu_x86_load_seg(env, R_FS, lduw(&sc->fs));
 799         cpu_x86_load_seg(env, R_ES, lduw(&sc->es));
 800         cpu_x86_load_seg(env, R_DS, lduw(&sc->ds));
 801
 802         env->regs[R_EDI] = ldl(&sc->edi);
 803         env->regs[R_ESI] = ldl(&sc->esi);
 804         env->regs[R_EBP] = ldl(&sc->ebp);
 805         env->regs[R_ESP] = ldl(&sc->esp);
 806         env->regs[R_EBX] = ldl(&sc->ebx);
 807         env->regs[R_EDX] = ldl(&sc->edx);
 808         env->regs[R_ECX] = ldl(&sc->ecx);
 809         env->eip = ldl(&sc->eip);
 810
 811         cpu_x86_load_seg(env, R_CS, lduw(&sc->cs) | 3);
 812         cpu_x86_load_seg(env, R_SS, lduw(&sc->ss) | 3);
 813
 814         {
 815                 unsigned int tmpflags;
 816                 tmpflags = ldl(&sc->eflags);
 817                 env->eflags = (env->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);
 818                 //              regs->orig_eax = -1;            /* disable syscall checks */
 819         }
 820
 821         {
 822                 struct _fpstate * buf;
 823                 buf = (void *)ldl(&sc->fpstate);
 824                 if (buf) {
 825 #if 0
 826                         if (verify_area(VERIFY_READ, buf, sizeof(*buf)))
 827                                 goto badframe;
 828 #endif
 829                         cpu_x86_frstor(env, (void *)buf, 1);
 830                 }
 831         }
 832
 833         *peax = ldl(&sc->eax);
 834         return err;
 835 #if 0
 836 badframe:
 837         return 1;
 838 #endif
 839 }
 840
 841 long do_sigreturn(CPUX86State *env)
 842 {
 843     struct sigframe *frame = (struct sigframe *)(env->regs[R_ESP] - 8);
 844     target_sigset_t target_set;
 845     sigset_t set;
 846     int eax, i;
 847
 848 #if defined(DEBUG_SIGNAL)
 849     fprintf(stderr, "do_sigreturn\n");
 850 #endif
 851     /* set blocked signals */
 852     if (__get_user(target_set.sig[0], &frame->sc.oldmask))
 853         goto badframe;
 854     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
 855         if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
 856             goto badframe;
 857     }
 858
 859     target_to_host_sigset_internal(&set, &target_set);
 860     sigprocmask(SIG_SETMASK, &set, NULL);
 861
 862     /* restore registers */
 863     if (restore_sigcontext(env, &frame->sc, &eax))
 864         goto badframe;
 865     return eax;
 866
 867 badframe:
 868     force_sig(TARGET_SIGSEGV);
 869     return 0;
 870 }
 871
 872 long do_rt_sigreturn(CPUX86State *env)
 873 {
 874         struct rt_sigframe *frame = (struct rt_sigframe *)(env->regs[R_ESP] - 4);
 875         sigset_t set;
 876         //      stack_t st;
 877         int eax;
 878
 879 #if 0
 880         if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
 881                 goto badframe;
 882 #endif
 883         target_to_host_sigset(&set, &frame->uc.uc_sigmask);
 884         sigprocmask(SIG_SETMASK, &set, NULL);
 885
 886         if (restore_sigcontext(env, &frame->uc.uc_mcontext, &eax))
 887                 goto badframe;
 888
 889 #if 0
 890         if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
 891                 goto badframe;
 892         /* It is more difficult to avoid calling this function than to
 893            call it and ignore errors.  */
 894         do_sigaltstack(&st, NULL, regs->esp);
 895 #endif
 896         return eax;
 897
 898 badframe:
 899         force_sig(TARGET_SIGSEGV);
 900         return 0;
 901 }
 902
 903 #elif defined(TARGET_ARM)
 904
 905 struct target_sigcontext {
 906         target_ulong trap_no;
 907         target_ulong error_code;
 908         target_ulong oldmask;
 909         target_ulong arm_r0;
 910         target_ulong arm_r1;
 911         target_ulong arm_r2;
 912         target_ulong arm_r3;
 913         target_ulong arm_r4;
 914         target_ulong arm_r5;
 915         target_ulong arm_r6;
 916         target_ulong arm_r7;
 917         target_ulong arm_r8;
 918         target_ulong arm_r9;
 919         target_ulong arm_r10;
 920         target_ulong arm_fp;
 921         target_ulong arm_ip;
 922         target_ulong arm_sp;
 923         target_ulong arm_lr;
 924         target_ulong arm_pc;
 925         target_ulong arm_cpsr;
 926         target_ulong fault_address;
 927 };
 928
 929 typedef struct target_sigaltstack {
 930         target_ulong ss_sp;
 931         int ss_flags;
 932         target_ulong ss_size;
 933 } target_stack_t;
 934
 935 struct target_ucontext {
 936     target_ulong uc_flags;
 937     target_ulong uc_link;
 938     target_stack_t uc_stack;
 939     struct target_sigcontext uc_mcontext;
 940     target_sigset_t  uc_sigmask;        /* mask last for extensibility */
 941 };
 942
 943 struct sigframe
 944 {
 945     struct target_sigcontext sc;
 946     target_ulong extramask[TARGET_NSIG_WORDS-1];
 947     target_ulong retcode;
 948 };
 949
 950 struct rt_sigframe
 951 {
 952     struct target_siginfo *pinfo;
 953     void *puc;
 954     struct target_siginfo info;
 955     struct target_ucontext uc;
 956     target_ulong retcode;
 957 };
 958
 959 #define TARGET_CONFIG_CPU_32 1
 960
 961 /*
 962  * For ARM syscalls, we encode the syscall number into the instruction.
 963  */
 964 #define SWI_SYS_SIGRETURN       (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE))
 965 #define SWI_SYS_RT_SIGRETURN    (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE))
 966
 967 /*
 968  * For Thumb syscalls, we pass the syscall number via r7.  We therefore
 969  * need two 16-bit instructions.
 970  */
 971 #define SWI_THUMB_SIGRETURN     (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn))
 972 #define SWI_THUMB_RT_SIGRETURN  (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn))
 973
 974 static const target_ulong retcodes[4] = {
 975         SWI_SYS_SIGRETURN,      SWI_THUMB_SIGRETURN,
 976         SWI_SYS_RT_SIGRETURN,   SWI_THUMB_RT_SIGRETURN
 977 };
 978
 979
 980 #define __put_user_error(x,p,e) __put_user(x, p)
 981 #define __get_user_error(x,p,e) __get_user(x, p)
 982
 983 static inline int valid_user_regs(CPUState *regs)
 984 {
 985     return 1;
 986 }
 987
 988 static int
 989 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
 990                  CPUState *env, unsigned long mask)
 991 {
 992         int err = 0;
 993
 994         __put_user_error(env->regs[0], &sc->arm_r0, err);
 995         __put_user_error(env->regs[1], &sc->arm_r1, err);
 996         __put_user_error(env->regs[2], &sc->arm_r2, err);
 997         __put_user_error(env->regs[3], &sc->arm_r3, err);
 998         __put_user_error(env->regs[4], &sc->arm_r4, err);
 999         __put_user_error(env->regs[5], &sc->arm_r5, err);
1000         __put_user_error(env->regs[6], &sc->arm_r6, err);
1001         __put_user_error(env->regs[7], &sc->arm_r7, err);
1002         __put_user_error(env->regs[8], &sc->arm_r8, err);
1003         __put_user_error(env->regs[9], &sc->arm_r9, err);
1004         __put_user_error(env->regs[10], &sc->arm_r10, err);
1005         __put_user_error(env->regs[11], &sc->arm_fp, err);
1006         __put_user_error(env->regs[12], &sc->arm_ip, err);
1007         __put_user_error(env->regs[13], &sc->arm_sp, err);
1008         __put_user_error(env->regs[14], &sc->arm_lr, err);
1009         __put_user_error(env->regs[15], &sc->arm_pc, err);
1010 #ifdef TARGET_CONFIG_CPU_32
1011         __put_user_error(env->cpsr, &sc->arm_cpsr, err);
1012 #endif
1013
1014         __put_user_error(/* current->thread.trap_no */ 0, &sc->trap_no, err);
1015         __put_user_error(/* current->thread.error_code */ 0, &sc->error_code, err);
1016         __put_user_error(/* current->thread.address */ 0, &sc->fault_address, err);
1017         __put_user_error(mask, &sc->oldmask, err);
1018
1019         return err;
1020 }
1021
1022 static inline void *
1023 get_sigframe(struct emulated_sigaction *ka, CPUState *regs, int framesize)
1024 {
1025         unsigned long sp = regs->regs[13];
1026
1027 #if 0
1028         /*
1029          * This is the X/Open sanctioned signal stack switching.
1030          */
1031         if ((ka->sa.sa_flags & SA_ONSTACK) && !sas_ss_flags(sp))
1032                 sp = current->sas_ss_sp + current->sas_ss_size;
1033 #endif
1034         /*
1035          * ATPCS B01 mandates 8-byte alignment
1036          */
1037         return (void *)((sp - framesize) & ~7);
1038 }
1039
1040 static int
1041 setup_return(CPUState *env, struct emulated_sigaction *ka,
1042              target_ulong *rc, void *frame, int usig)
1043 {
1044         target_ulong handler = (target_ulong)ka->sa._sa_handler;
1045         target_ulong retcode;
1046         int thumb = 0;
1047 #if defined(TARGET_CONFIG_CPU_32)
1048         target_ulong cpsr = env->cpsr;
1049
1050 #if 0
1051         /*
1052          * Maybe we need to deliver a 32-bit signal to a 26-bit task.
1053          */
1054         if (ka->sa.sa_flags & SA_THIRTYTWO)
1055                 cpsr = (cpsr & ~MODE_MASK) | USR_MODE;
1056
1057 #ifdef CONFIG_ARM_THUMB
1058         if (elf_hwcap & HWCAP_THUMB) {
1059                 /*
1060                  * The LSB of the handler determines if we're going to
1061                  * be using THUMB or ARM mode for this signal handler.
1062                  */
1063                 thumb = handler & 1;
1064
1065                 if (thumb)
1066                         cpsr |= T_BIT;
1067                 else
1068                         cpsr &= ~T_BIT;
1069         }
1070 #endif
1071 #endif
1072 #endif /* TARGET_CONFIG_CPU_32 */
1073
1074         if (ka->sa.sa_flags & TARGET_SA_RESTORER) {
1075                 retcode = (target_ulong)ka->sa.sa_restorer;
1076         } else {
1077                 unsigned int idx = thumb;
1078
1079                 if (ka->sa.sa_flags & TARGET_SA_SIGINFO)
1080                         idx += 2;
1081
1082                 if (__put_user(retcodes[idx], rc))
1083                         return 1;
1084 #if 0
1085                 flush_icache_range((target_ulong)rc,
1086                                    (target_ulong)(rc + 1));
1087 #endif
1088                 retcode = ((target_ulong)rc) + thumb;
1089         }
1090
1091         env->regs[0] = usig;
1092         env->regs[13] = (target_ulong)frame;
1093         env->regs[14] = retcode;
1094         env->regs[15] = handler & (thumb ? ~1 : ~3);
1095
1096 #ifdef TARGET_CONFIG_CPU_32
1097         env->cpsr = cpsr;
1098 #endif
1099
1100         return 0;
1101 }
1102
1103 static void setup_frame(int usig, struct emulated_sigaction *ka,
1104                         target_sigset_t *set, CPUState *regs)
1105 {
1106         struct sigframe *frame = get_sigframe(ka, regs, sizeof(*frame));
1107         int i, err = 0;
1108
1109         err |= setup_sigcontext(&frame->sc, /*&frame->fpstate,*/ regs, set->sig[0]);
1110
1111         for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1112             if (__put_user(set->sig[i], &frame->extramask[i - 1]))
1113                 return;
1114         }
1115
1116         if (err == 0)
1117             err = setup_return(regs, ka, &frame->retcode, frame, usig);
1118         //      return err;
1119 }
1120
1121 static void setup_rt_frame(int usig, struct emulated_sigaction *ka,
1122                            target_siginfo_t *info,
1123                            target_sigset_t *set, CPUState *env)
1124 {
1125         struct rt_sigframe *frame = get_sigframe(ka, env, sizeof(*frame));
1126         int i, err = 0;
1127
1128         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
1129             return /* 1 */;
1130
1131         __put_user_error(&frame->info, (target_ulong *)&frame->pinfo, err);
1132         __put_user_error(&frame->uc, (target_ulong *)&frame->puc, err);
1133         err |= copy_siginfo_to_user(&frame->info, info);
1134
1135         /* Clear all the bits of the ucontext we don't use.  */
1136         err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext));
1137
1138         err |= setup_sigcontext(&frame->uc.uc_mcontext, /*&frame->fpstate,*/
1139                                 env, set->sig[0]);
1140         for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1141             if (__put_user(set->sig[i], &frame->uc.uc_sigmask.sig[i]))
1142                 return;
1143         }
1144
1145         if (err == 0)
1146                 err = setup_return(env, ka, &frame->retcode, frame, usig);
1147
1148         if (err == 0) {
1149                 /*
1150                  * For realtime signals we must also set the second and third
1151                  * arguments for the signal handler.
1152                  *   -- Peter Maydell <[email protected]> 2000-12-06
1153                  */
1154             env->regs[1] = (target_ulong)frame->pinfo;
1155             env->regs[2] = (target_ulong)frame->puc;
1156         }
1157
1158         //      return err;
1159 }
1160
1161 static int
1162 restore_sigcontext(CPUState *env, struct target_sigcontext *sc)
1163 {
1164         int err = 0;
1165
1166         __get_user_error(env->regs[0], &sc->arm_r0, err);
1167         __get_user_error(env->regs[1], &sc->arm_r1, err);
1168         __get_user_error(env->regs[2], &sc->arm_r2, err);
1169         __get_user_error(env->regs[3], &sc->arm_r3, err);
1170         __get_user_error(env->regs[4], &sc->arm_r4, err);
1171         __get_user_error(env->regs[5], &sc->arm_r5, err);
1172         __get_user_error(env->regs[6], &sc->arm_r6, err);
1173         __get_user_error(env->regs[7], &sc->arm_r7, err);
1174         __get_user_error(env->regs[8], &sc->arm_r8, err);
1175         __get_user_error(env->regs[9], &sc->arm_r9, err);
1176         __get_user_error(env->regs[10], &sc->arm_r10, err);
1177         __get_user_error(env->regs[11], &sc->arm_fp, err);
1178         __get_user_error(env->regs[12], &sc->arm_ip, err);
1179         __get_user_error(env->regs[13], &sc->arm_sp, err);
1180         __get_user_error(env->regs[14], &sc->arm_lr, err);
1181         __get_user_error(env->regs[15], &sc->arm_pc, err);
1182 #ifdef TARGET_CONFIG_CPU_32
1183         __get_user_error(env->cpsr, &sc->arm_cpsr, err);
1184 #endif
1185
1186         err |= !valid_user_regs(env);
1187
1188         return err;
1189 }
1190
1191 long do_sigreturn(CPUState *env)
1192 {
1193         struct sigframe *frame;
1194         target_sigset_t set;
1195         sigset_t host_set;
1196         int i;
1197
1198         /*
1199          * Since we stacked the signal on a 64-bit boundary,
1200          * then 'sp' should be word aligned here.  If it's
1201          * not, then the user is trying to mess with us.
1202          */
1203         if (env->regs[13] & 7)
1204                 goto badframe;
1205
1206         frame = (struct sigframe *)env->regs[13];
1207
1208 #if 0
1209         if (verify_area(VERIFY_READ, frame, sizeof (*frame)))
1210                 goto badframe;
1211 #endif
1212         if (__get_user(set.sig[0], &frame->sc.oldmask))
1213             goto badframe;
1214         for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1215             if (__get_user(set.sig[i], &frame->extramask[i - 1]))
1216                 goto badframe;
1217         }
1218
1219         target_to_host_sigset_internal(&host_set, &set);
1220         sigprocmask(SIG_SETMASK, &host_set, NULL);
1221
1222         if (restore_sigcontext(env, &frame->sc))
1223                 goto badframe;
1224
1225 #if 0
1226         /* Send SIGTRAP if we're single-stepping */
1227         if (ptrace_cancel_bpt(current))
1228                 send_sig(SIGTRAP, current, 1);
1229 #endif
1230         return env->regs[0];
1231
1232 badframe:
1233         force_sig(SIGSEGV /* , current */);
1234         return 0;
1235 }
1236
1237 long do_rt_sigreturn(CPUState *env)
1238 {
1239         struct rt_sigframe *frame;
1240         sigset_t host_set;
1241
1242         /*
1243          * Since we stacked the signal on a 64-bit boundary,
1244          * then 'sp' should be word aligned here.  If it's
1245          * not, then the user is trying to mess with us.
1246          */
1247         if (env->regs[13] & 7)
1248                 goto badframe;
1249
1250         frame = (struct rt_sigframe *)env->regs[13];
1251
1252 #if 0
1253         if (verify_area(VERIFY_READ, frame, sizeof (*frame)))
1254                 goto badframe;
1255 #endif
1256         target_to_host_sigset(&host_set, &frame->uc.uc_sigmask);
1257         sigprocmask(SIG_SETMASK, &host_set, NULL);
1258
1259         if (restore_sigcontext(env, &frame->uc.uc_mcontext))
1260                 goto badframe;
1261
1262 #if 0
1263         /* Send SIGTRAP if we're single-stepping */
1264         if (ptrace_cancel_bpt(current))
1265                 send_sig(SIGTRAP, current, 1);
1266 #endif
1267         return env->regs[0];
1268
1269 badframe:
1270         force_sig(SIGSEGV /* , current */);
1271         return 0;
1272 }
1273
1274 #elif defined(TARGET_SPARC)
1275 #define __SUNOS_MAXWIN   31
1276
1277 /* This is what SunOS does, so shall I. */
1278 struct target_sigcontext {
1279         target_ulong sigc_onstack;      /* state to restore */
1280
1281         target_ulong sigc_mask;         /* sigmask to restore */
1282         target_ulong sigc_sp;           /* stack pointer */
1283         target_ulong sigc_pc;           /* program counter */
1284         target_ulong sigc_npc;          /* next program counter */
1285         target_ulong sigc_psr;          /* for condition codes etc */
1286         target_ulong sigc_g1;           /* User uses these two registers */
1287         target_ulong sigc_o0;           /* within the trampoline code. */
1288
1289         /* Now comes information regarding the users window set
1290          * at the time of the signal.
1291          */
1292         target_ulong sigc_oswins;       /* outstanding windows */
1293
1294         /* stack ptrs for each regwin buf */
1295         char *sigc_spbuf[__SUNOS_MAXWIN];
1296
1297         /* Windows to restore after signal */
1298         struct {
1299                 target_ulong locals[8];
1300                 target_ulong ins[8];
1301         } sigc_wbuf[__SUNOS_MAXWIN];
1302 };
1303 /* A Sparc stack frame */
1304 struct sparc_stackf {
1305         target_ulong locals[8];
1306         target_ulong ins[6];
1307         struct sparc_stackf *fp;
1308         target_ulong callers_pc;
1309         char *structptr;
1310         target_ulong xargs[6];
1311         target_ulong xxargs[1];
1312 };
1313
1314 typedef struct {
1315         struct {
1316                 target_ulong psr;
1317                 target_ulong pc;
1318                 target_ulong npc;
1319                 target_ulong y;
1320                 target_ulong u_regs[16]; /* globals and ins */
1321         }               si_regs;
1322         int             si_mask;
1323 } __siginfo_t;
1324
1325 typedef struct {
1326         unsigned   long si_float_regs [32];
1327         unsigned   long si_fsr;
1328         unsigned   long si_fpqdepth;
1329         struct {
1330                 unsigned long *insn_addr;
1331                 unsigned long insn;
1332         } si_fpqueue [16];
1333 } __siginfo_fpu_t;
1334
1335
1336 struct target_signal_frame {
1337         struct sparc_stackf     ss;
1338         __siginfo_t             info;
1339         __siginfo_fpu_t         *fpu_save;
1340         target_ulong            insns[2] __attribute__ ((aligned (8)));
1341         target_ulong            extramask[TARGET_NSIG_WORDS - 1];
1342         target_ulong            extra_size; /* Should be 0 */
1343         __siginfo_fpu_t         fpu_state;
1344 };
1345 struct target_rt_signal_frame {
1346         struct sparc_stackf     ss;
1347         siginfo_t               info;
1348         target_ulong            regs[20];
1349         sigset_t                mask;
1350         __siginfo_fpu_t         *fpu_save;
1351         unsigned int            insns[2];
1352         stack_t                 stack;
1353         unsigned int            extra_size; /* Should be 0 */
1354         __siginfo_fpu_t         fpu_state;
1355 };
1356
1357 #define UREG_O0        16
1358 #define UREG_O6        22
1359 #define UREG_I0        0
1360 #define UREG_I1        1
1361 #define UREG_I2        2
1362 #define UREG_I6        6
1363 #define UREG_I7        7
1364 #define UREG_L0        8
1365 #define UREG_FP        UREG_I6
1366 #define UREG_SP        UREG_O6
1367
1368 static inline void *get_sigframe(struct emulated_sigaction *sa, CPUState *env, unsigned long framesize)
1369 {
1370         unsigned long sp;
1371
1372         sp = env->regwptr[UREG_FP];
1373 #if 0
1374
1375         /* This is the X/Open sanctioned signal stack switching.  */
1376         if (sa->sa_flags & TARGET_SA_ONSTACK) {
1377                 if (!on_sig_stack(sp) && !((current->sas_ss_sp + current->sas_ss_size) & 7))
1378                         sp = current->sas_ss_sp + current->sas_ss_size;
1379         }
1380 #endif
1381         return (void *)(sp - framesize);
1382 }
1383
1384 static int
1385 setup___siginfo(__siginfo_t *si, CPUState *env, target_ulong mask)
1386 {
1387         int err = 0, i;
1388
1389         err |= __put_user(env->psr, &si->si_regs.psr);
1390         err |= __put_user(env->pc, &si->si_regs.pc);
1391         err |= __put_user(env->npc, &si->si_regs.npc);
1392         err |= __put_user(env->y, &si->si_regs.y);
1393         for (i=0; i < 7; i++) {
1394                 err |= __put_user(env->gregs[i], &si->si_regs.u_regs[i]);
1395         }
1396         for (i=0; i < 7; i++) {
1397                 err |= __put_user(env->regwptr[UREG_I0 + i], &si->si_regs.u_regs[i+8]);
1398         }
1399         err |= __put_user(mask, &si->si_mask);
1400         return err;
1401 }
1402
1403 static int
1404 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
1405                  CPUState *env, unsigned long mask)
1406 {
1407         int err = 0;
1408
1409         err |= __put_user(mask, &sc->sigc_mask);
1410         err |= __put_user(env->regwptr[UREG_SP], &sc->sigc_sp);
1411         err |= __put_user(env->pc, &sc->sigc_pc);
1412         err |= __put_user(env->npc, &sc->sigc_npc);
1413         err |= __put_user(env->psr, &sc->sigc_psr);
1414         err |= __put_user(env->gregs[1], &sc->sigc_g1);
1415         err |= __put_user(env->regwptr[UREG_O0], &sc->sigc_o0);
1416
1417         return err;
1418 }
1419 #define NF_ALIGNEDSZ  (((sizeof(struct target_signal_frame) + 7) & (~7)))
1420
1421 static void setup_frame(int sig, struct emulated_sigaction *ka,
1422                         target_sigset_t *set, CPUState *env)
1423 {
1424         struct target_signal_frame *sf;
1425         int sigframe_size, err, i;
1426
1427         /* 1. Make sure everything is clean */
1428         //synchronize_user_stack();
1429
1430         sigframe_size = NF_ALIGNEDSZ;
1431
1432         sf = (struct target_signal_frame *)
1433                 get_sigframe(ka, env, sigframe_size);
1434
1435         //fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
1436 #if 0
1437         if (invalid_frame_pointer(sf, sigframe_size))
1438                 goto sigill_and_return;
1439 #endif
1440         /* 2. Save the current process state */
1441         err = setup___siginfo(&sf->info, env, set->sig[0]);
1442         err |= __put_user(0, &sf->extra_size);
1443
1444         //err |= save_fpu_state(regs, &sf->fpu_state);
1445         //err |= __put_user(&sf->fpu_state, &sf->fpu_save);
1446
1447         err |= __put_user(set->sig[0], &sf->info.si_mask);
1448         for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
1449                 err |= __put_user(set->sig[i + 1], &sf->extramask[i]);
1450         }
1451
1452         for (i = 0; i < 7; i++) {
1453                 err |= __put_user(env->regwptr[i + UREG_L0], &sf->ss.locals[i]);
1454         }
1455         for (i = 0; i < 7; i++) {
1456                 err |= __put_user(env->regwptr[i + UREG_I0], &sf->ss.ins[i]);
1457         }
1458         if (err)
1459                 goto sigsegv;
1460
1461         /* 3. signal handler back-trampoline and parameters */
1462         env->regwptr[UREG_FP] = (target_ulong) sf;
1463         env->regwptr[UREG_I0] = sig;
1464         env->regwptr[UREG_I1] = (target_ulong) &sf->info;
1465         env->regwptr[UREG_I2] = (target_ulong) &sf->info;
1466
1467         /* 4. signal handler */
1468         env->pc = (unsigned long) ka->sa._sa_handler;
1469         env->npc = (env->pc + 4);
1470         /* 5. return to kernel instructions */
1471         if (ka->sa.sa_restorer)
1472                 env->regwptr[UREG_I7] = (unsigned long)ka->sa.sa_restorer;
1473         else {
1474                 env->regwptr[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2);
1475
1476                 /* mov __NR_sigreturn, %g1 */
1477                 err |= __put_user(0x821020d8, &sf->insns[0]);
1478
1479                 /* t 0x10 */
1480                 err |= __put_user(0x91d02010, &sf->insns[1]);
1481                 if (err)
1482                         goto sigsegv;
1483
1484                 /* Flush instruction space. */
1485                 //flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
1486                 tb_flush(env);
1487         }
1488         //cpu_dump_state(env, stderr, fprintf, 0);
1489         return;
1490
1491 sigill_and_return:
1492         force_sig(TARGET_SIGILL);
1493 sigsegv:
1494         //fprintf(stderr, "force_sig\n");
1495         force_sig(TARGET_SIGSEGV);
1496 }
1497 static inline int
1498 restore_fpu_state(CPUState *env, __siginfo_fpu_t *fpu)
1499 {
1500         int err;
1501 #if 0
1502 #ifdef CONFIG_SMP
1503         if (current->flags & PF_USEDFPU)
1504                 regs->psr &= ~PSR_EF;
1505 #else
1506         if (current == last_task_used_math) {
1507                 last_task_used_math = 0;
1508                 regs->psr &= ~PSR_EF;
1509         }
1510 #endif
1511         current->used_math = 1;
1512         current->flags &= ~PF_USEDFPU;
1513 #endif
1514 #if 0
1515         if (verify_area (VERIFY_READ, fpu, sizeof(*fpu)))
1516                 return -EFAULT;
1517 #endif
1518
1519         err = __copy_from_user(&env->fpr[0], &fpu->si_float_regs[0],
1520                                      (sizeof(unsigned long) * 32));
1521         err |= __get_user(env->fsr, &fpu->si_fsr);
1522 #if 0
1523         err |= __get_user(current->thread.fpqdepth, &fpu->si_fpqdepth);
1524         if (current->thread.fpqdepth != 0)
1525                 err |= __copy_from_user(&current->thread.fpqueue[0],
1526                                         &fpu->si_fpqueue[0],
1527                                         ((sizeof(unsigned long) +
1528                                         (sizeof(unsigned long *)))*16));
1529 #endif
1530         return err;
1531 }
1532
1533
1534 static void setup_rt_frame(int sig, struct emulated_sigaction *ka,
1535                            target_siginfo_t *info,
1536                            target_sigset_t *set, CPUState *env)
1537 {
1538     fprintf(stderr, "setup_rt_frame: not implemented\n");
1539 }
1540
1541 long do_sigreturn(CPUState *env)
1542 {
1543         struct target_signal_frame *sf;
1544         uint32_t up_psr, pc, npc;
1545         target_sigset_t set;
1546         sigset_t host_set;
1547         __siginfo_fpu_t *fpu_save;
1548         int err, i;
1549
1550         sf = (struct target_signal_frame *) env->regwptr[UREG_FP];
1551         fprintf(stderr, "sigreturn\n");
1552         fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
1553         //cpu_dump_state(env, stderr, fprintf, 0);
1554
1555         /* 1. Make sure we are not getting garbage from the user */
1556 #if 0
1557         if (verify_area (VERIFY_READ, sf, sizeof (*sf)))
1558                 goto segv_and_exit;
1559 #endif
1560
1561         if (((uint) sf) & 3)
1562                 goto segv_and_exit;
1563
1564         err = __get_user(pc,  &sf->info.si_regs.pc);
1565         err |= __get_user(npc, &sf->info.si_regs.npc);
1566
1567         fprintf(stderr, "pc: %lx npc %lx\n", pc, npc);
1568         if ((pc | npc) & 3)
1569                 goto segv_and_exit;
1570
1571         /* 2. Restore the state */
1572         err |= __get_user(up_psr, &sf->info.si_regs.psr);
1573
1574         /* User can only change condition codes and FPU enabling in %psr. */
1575         env->psr = (up_psr & ~(PSR_ICC /* | PSR_EF */))
1576                   | (env->psr & (PSR_ICC /* | PSR_EF */));
1577         fprintf(stderr, "psr: %x\n", env->psr);
1578         env->pc = pc-4;
1579         env->npc = pc;
1580         err |= __get_user(env->y, &sf->info.si_regs.y);
1581         for (i=0; i < 7; i++) {
1582                 err |= __get_user(env->gregs[i], &sf->info.si_regs.u_regs[i]);
1583         }
1584         for (i=0; i < 7; i++) {
1585                 err |= __get_user(env->regwptr[i + UREG_I0], &sf->info.si_regs.u_regs[i+8]);
1586         }
1587
1588         err |= __get_user(fpu_save, &sf->fpu_save);
1589
1590         //if (fpu_save)
1591         //        err |= restore_fpu_state(env, fpu_save);
1592
1593         /* This is pretty much atomic, no amount locking would prevent
1594          * the races which exist anyways.
1595          */
1596         err |= __get_user(set.sig[0], &sf->info.si_mask);
1597         for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1598             err |= (__get_user(set.sig[i], &sf->extramask[i - 1]));
1599         }
1600
1601         target_to_host_sigset_internal(&host_set, &set);
1602         sigprocmask(SIG_SETMASK, &host_set, NULL);
1603
1604         if (err)
1605                 goto segv_and_exit;
1606
1607         fprintf(stderr, "returning %lx\n", env->regwptr[0]);
1608         return env->regwptr[0];
1609
1610 segv_and_exit:
1611         force_sig(TARGET_SIGSEGV);
1612 }
1613
1614 long do_rt_sigreturn(CPUState *env)
1615 {
1616     fprintf(stderr, "do_rt_sigreturn: not implemented\n");
1617     return -ENOSYS;
1618 }
1619
1620
1621 #else
1622
1623 static void setup_frame(int sig, struct emulated_sigaction *ka,
1624                         target_sigset_t *set, CPUState *env)
1625 {
1626     fprintf(stderr, "setup_frame: not implemented\n");
1627 }
1628
1629 static void setup_rt_frame(int sig, struct emulated_sigaction *ka,
1630                            target_siginfo_t *info,
1631                            target_sigset_t *set, CPUState *env)
1632 {
1633     fprintf(stderr, "setup_rt_frame: not implemented\n");
1634 }
1635
1636 long do_sigreturn(CPUState *env)
1637 {
1638     fprintf(stderr, "do_sigreturn: not implemented\n");
1639     return -ENOSYS;
1640 }
1641
1642 long do_rt_sigreturn(CPUState *env)
1643 {
1644     fprintf(stderr, "do_rt_sigreturn: not implemented\n");
1645     return -ENOSYS;
1646 }
1647
1648 #endif
1649
1650 void process_pending_signals(void *cpu_env)
1651 {
1652     int sig;
1653     target_ulong handler;
1654     sigset_t set, old_set;
1655     target_sigset_t target_old_set;
1656     struct emulated_sigaction *k;
1657     struct sigqueue *q;
1658
1659     if (!signal_pending)
1660         return;
1661
1662     k = sigact_table;
1663     for(sig = 1; sig <= TARGET_NSIG; sig++) {
1664         if (k->pending)
1665             goto handle_signal;
1666         k++;
1667     }
1668     /* if no signal is pending, just return */
1669     signal_pending = 0;
1670     return;
1671
1672  handle_signal:
1673 #ifdef DEBUG_SIGNAL
1674     fprintf(stderr, "qemu: process signal %d\n", sig);
1675 #endif
1676     /* dequeue signal */
1677     q = k->first;
1678     k->first = q->next;
1679     if (!k->first)
1680         k->pending = 0;
1681
1682     handler = k->sa._sa_handler;
1683     if (handler == TARGET_SIG_DFL) {
1684         /* default handler : ignore some signal. The other are fatal */
1685         if (sig != TARGET_SIGCHLD &&
1686             sig != TARGET_SIGURG &&
1687             sig != TARGET_SIGWINCH) {
1688             force_sig(sig);
1689         }
1690     } else if (handler == TARGET_SIG_IGN) {
1691         /* ignore sig */
1692     } else if (handler == TARGET_SIG_ERR) {
1693         force_sig(sig);
1694     } else {
1695         /* compute the blocked signals during the handler execution */
1696         target_to_host_sigset(&set, &k->sa.sa_mask);
1697         /* SA_NODEFER indicates that the current signal should not be
1698            blocked during the handler */
1699         if (!(k->sa.sa_flags & TARGET_SA_NODEFER))
1700             sigaddset(&set, target_to_host_signal(sig));
1701
1702         /* block signals in the handler using Linux */
1703         sigprocmask(SIG_BLOCK, &set, &old_set);
1704         /* save the previous blocked signal state to restore it at the
1705            end of the signal execution (see do_sigreturn) */
1706         host_to_target_sigset_internal(&target_old_set, &old_set);
1707
1708         /* if the CPU is in VM86 mode, we restore the 32 bit values */
1709 #ifdef TARGET_I386
1710         {
1711             CPUX86State *env = cpu_env;
1712             if (env->eflags & VM_MASK)
1713                 save_v86_state(env);
1714         }
1715 #endif
1716         /* prepare the stack frame of the virtual CPU */
1717         if (k->sa.sa_flags & TARGET_SA_SIGINFO)
1718             setup_rt_frame(sig, k, &q->info, &target_old_set, cpu_env);
1719         else
1720             setup_frame(sig, k, &target_old_set, cpu_env);
1721         if (k->sa.sa_flags & TARGET_SA_RESETHAND)
1722             k->sa._sa_handler = TARGET_SIG_DFL;
1723     }
1724     if (q != &k->info)
1725         free_sigqueue(q);
1726 }
1727
1728