vcs.maemo.org Git - qemu/blob - 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 <signal.h>
  25 #include <errno.h>
  26 #include <sys/ucontext.h>
  27
  28 #include "qemu.h"
  29
  30 //#define DEBUG_SIGNAL
  31
  32 #define MAX_SIGQUEUE_SIZE 1024
  33
  34 struct sigqueue {
  35     struct sigqueue *next;
  36     target_siginfo_t info;
  37 };
  38
  39 struct emulated_sigaction {
  40     struct target_sigaction sa;
  41     int pending; /* true if signal is pending */
  42     struct sigqueue *first;
  43     struct sigqueue info; /* in order to always have memory for the
  44                              first signal, we put it here */
  45 };
  46
  47 static struct emulated_sigaction sigact_table[TARGET_NSIG];
  48 static struct sigqueue sigqueue_table[MAX_SIGQUEUE_SIZE]; /* siginfo queue */
  49 static struct sigqueue *first_free; /* first free siginfo queue entry */
  50 static int signal_pending; /* non zero if a signal may be pending */
  51
  52 static void host_signal_handler(int host_signum, siginfo_t *info,
  53                                 void *puc);
  54
  55 /* XXX: do it properly */
  56 static inline int host_to_target_signal(int sig)
  57 {
  58     return sig;
  59 }
  60
  61 static inline int target_to_host_signal(int sig)
  62 {
  63     return sig;
  64 }
  65
  66 void host_to_target_sigset(target_sigset_t *d, sigset_t *s)
  67 {
  68     int i;
  69     for(i = 0;i < TARGET_NSIG_WORDS; i++) {
  70         d->sig[i] = tswapl(((unsigned long *)s)[i]);
  71     }
  72 }
  73
  74 void target_to_host_sigset(sigset_t *d, target_sigset_t *s)
  75 {
  76     int i;
  77     for(i = 0;i < TARGET_NSIG_WORDS; i++) {
  78         ((unsigned long *)d)[i] = tswapl(s->sig[i]);
  79     }
  80 }
  81
  82 void host_to_target_old_sigset(target_ulong *old_sigset,
  83                                const sigset_t *sigset)
  84 {
  85     *old_sigset = tswap32(*(unsigned long *)sigset & 0xffffffff);
  86 }
  87
  88 void target_to_host_old_sigset(sigset_t *sigset,
  89                                const target_ulong *old_sigset)
  90 {
  91     sigemptyset(sigset);
  92     *(unsigned long *)sigset = tswapl(*old_sigset);
  93 }
  94
  95 /* siginfo conversion */
  96
  97 static inline void host_to_target_siginfo_noswap(target_siginfo_t *tinfo,
  98                                                  const siginfo_t *info)
  99 {
 100     int sig;
 101     sig = host_to_target_signal(info->si_signo);
 102     tinfo->si_signo = sig;
 103     tinfo->si_errno = 0;
 104     tinfo->si_code = 0;
 105     if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV || sig == SIGBUS) {
 106         /* should never come here, but who knows. The information for
 107            the target is irrelevant */
 108         tinfo->_sifields._sigfault._addr = 0;
 109     } else if (sig >= TARGET_SIGRTMIN) {
 110         tinfo->_sifields._rt._pid = info->si_pid;
 111         tinfo->_sifields._rt._uid = info->si_uid;
 112         /* XXX: potential problem if 64 bit */
 113         tinfo->_sifields._rt._sigval.sival_ptr =
 114             (target_ulong)info->si_value.sival_ptr;
 115     }
 116 }
 117
 118 static void tswap_siginfo(target_siginfo_t *tinfo,
 119                           const target_siginfo_t *info)
 120 {
 121     int sig;
 122     sig = info->si_signo;
 123     tinfo->si_signo = tswap32(sig);
 124     tinfo->si_errno = tswap32(info->si_errno);
 125     tinfo->si_code = tswap32(info->si_code);
 126     if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV || sig == SIGBUS) {
 127         tinfo->_sifields._sigfault._addr =
 128             tswapl(info->_sifields._sigfault._addr);
 129     } else if (sig >= TARGET_SIGRTMIN) {
 130         tinfo->_sifields._rt._pid = tswap32(info->_sifields._rt._pid);
 131         tinfo->_sifields._rt._uid = tswap32(info->_sifields._rt._uid);
 132         tinfo->_sifields._rt._sigval.sival_ptr =
 133             tswapl(info->_sifields._rt._sigval.sival_ptr);
 134     }
 135 }
 136
 137
 138 void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info)
 139 {
 140     host_to_target_siginfo_noswap(tinfo, info);
 141     tswap_siginfo(tinfo, tinfo);
 142 }
 143
 144 /* XXX: we support only POSIX RT signals are used. */
 145 /* XXX: find a solution for 64 bit (additionnal malloced data is needed) */
 146 void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo)
 147 {
 148     info->si_signo = tswap32(tinfo->si_signo);
 149     info->si_errno = tswap32(tinfo->si_errno);
 150     info->si_code = tswap32(tinfo->si_code);
 151     info->si_pid = tswap32(tinfo->_sifields._rt._pid);
 152     info->si_uid = tswap32(tinfo->_sifields._rt._uid);
 153     info->si_value.sival_ptr =
 154         (void *)tswapl(tinfo->_sifields._rt._sigval.sival_ptr);
 155 }
 156
 157 void signal_init(void)
 158 {
 159     struct sigaction act;
 160     int i;
 161
 162     /* set all host signal handlers. ALL signals are blocked during
 163        the handlers to serialize them. */
 164     sigfillset(&act.sa_mask);
 165     act.sa_flags = SA_SIGINFO;
 166     act.sa_sigaction = host_signal_handler;
 167     for(i = 1; i < NSIG; i++) {
 168         sigaction(i, &act, NULL);
 169     }
 170
 171     memset(sigact_table, 0, sizeof(sigact_table));
 172
 173     first_free = &sigqueue_table[0];
 174     for(i = 0; i < MAX_SIGQUEUE_SIZE - 1; i++)
 175         sigqueue_table[i].next = &sigqueue_table[i + 1];
 176     sigqueue_table[MAX_SIGQUEUE_SIZE - 1].next = NULL;
 177 }
 178
 179 /* signal queue handling */
 180
 181 static inline struct sigqueue *alloc_sigqueue(void)
 182 {
 183     struct sigqueue *q = first_free;
 184     if (!q)
 185         return NULL;
 186     first_free = q->next;
 187     return q;
 188 }
 189
 190 static inline void free_sigqueue(struct sigqueue *q)
 191 {
 192     q->next = first_free;
 193     first_free = q;
 194 }
 195
 196 /* abort execution with signal */
 197 void __attribute((noreturn)) force_sig(int sig)
 198 {
 199     int host_sig;
 200     host_sig = target_to_host_signal(sig);
 201     fprintf(stderr, "qemu: uncaught target signal %d (%s) - exiting\n",
 202             sig, strsignal(host_sig));
 203 #if 1
 204     _exit(-host_sig);
 205 #else
 206     {
 207         struct sigaction act;
 208         sigemptyset(&act.sa_mask);
 209         act.sa_flags = SA_SIGINFO;
 210         act.sa_sigaction = SIG_DFL;
 211         sigaction(SIGABRT, &act, NULL);
 212         abort();
 213     }
 214 #endif
 215 }
 216
 217 /* queue a signal so that it will be send to the virtual CPU as soon
 218    as possible */
 219 int queue_signal(int sig, target_siginfo_t *info)
 220 {
 221     struct emulated_sigaction *k;
 222     struct sigqueue *q, **pq;
 223     target_ulong handler;
 224
 225 #if defined(DEBUG_SIGNAL)
 226     fprintf(stderr, "queue_signal: sig=%d\n",
 227             sig);
 228 #endif
 229     k = &sigact_table[sig - 1];
 230     handler = k->sa._sa_handler;
 231     if (handler == TARGET_SIG_DFL) {
 232         /* default handler : ignore some signal. The other are fatal */
 233         if (sig != TARGET_SIGCHLD &&
 234             sig != TARGET_SIGURG &&
 235             sig != TARGET_SIGWINCH) {
 236             force_sig(sig);
 237         } else {
 238             return 0; /* indicate ignored */
 239         }
 240     } else if (handler == TARGET_SIG_IGN) {
 241         /* ignore signal */
 242         return 0;
 243     } else if (handler == TARGET_SIG_ERR) {
 244         force_sig(sig);
 245     } else {
 246         pq = &k->first;
 247         if (sig < TARGET_SIGRTMIN) {
 248             /* if non real time signal, we queue exactly one signal */
 249             if (!k->pending)
 250                 q = &k->info;
 251             else
 252                 return 0;
 253         } else {
 254             if (!k->pending) {
 255                 /* first signal */
 256                 q = &k->info;
 257             } else {
 258                 q = alloc_sigqueue();
 259                 if (!q)
 260                     return -EAGAIN;
 261                 while (*pq != NULL)
 262                     pq = &(*pq)->next;
 263             }
 264         }
 265         *pq = q;
 266         q->info = *info;
 267         q->next = NULL;
 268         k->pending = 1;
 269         /* signal that a new signal is pending */
 270         signal_pending = 1;
 271         return 1; /* indicates that the signal was queued */
 272     }
 273 }
 274
 275 #if defined(DEBUG_SIGNAL)
 276 #ifdef __i386__
 277 static void dump_regs(struct ucontext *uc)
 278 {
 279     fprintf(stderr,
 280             "EAX=%08x EBX=%08x ECX=%08x EDX=%08x\n"
 281             "ESI=%08x EDI=%08x EBP=%08x ESP=%08x\n"
 282             "EFL=%08x EIP=%08x\n",
 283             uc->uc_mcontext.gregs[EAX],
 284             uc->uc_mcontext.gregs[EBX],
 285             uc->uc_mcontext.gregs[ECX],
 286             uc->uc_mcontext.gregs[EDX],
 287             uc->uc_mcontext.gregs[ESI],
 288             uc->uc_mcontext.gregs[EDI],
 289             uc->uc_mcontext.gregs[EBP],
 290             uc->uc_mcontext.gregs[ESP],
 291             uc->uc_mcontext.gregs[EFL],
 292             uc->uc_mcontext.gregs[EIP]);
 293 }
 294 #else
 295 static void dump_regs(struct ucontext *uc)
 296 {
 297 }
 298 #endif
 299
 300 #endif
 301
 302 static void host_signal_handler(int host_signum, siginfo_t *info,
 303                                 void *puc)
 304 {
 305     int sig;
 306     target_siginfo_t tinfo;
 307
 308     /* the CPU emulator uses some host signals to detect exceptions,
 309        we we forward to it some signals */
 310     if (host_signum == SIGSEGV || host_signum == SIGBUS) {
 311         if (cpu_x86_signal_handler(host_signum, info, puc))
 312             return;
 313     }
 314
 315     /* get target signal number */
 316     sig = host_to_target_signal(host_signum);
 317     if (sig < 1 || sig > TARGET_NSIG)
 318         return;
 319 #if defined(DEBUG_SIGNAL)
 320     fprintf(stderr, "qemu: got signal %d\n", sig);
 321     dump_regs(puc);
 322 #endif
 323     host_to_target_siginfo_noswap(&tinfo, info);
 324     if (queue_signal(sig, &tinfo) == 1) {
 325         /* interrupt the virtual CPU as soon as possible */
 326         cpu_x86_interrupt(global_env);
 327     }
 328 }
 329
 330 int do_sigaction(int sig, const struct target_sigaction *act,
 331                  struct target_sigaction *oact)
 332 {
 333     struct emulated_sigaction *k;
 334
 335     if (sig < 1 || sig > TARGET_NSIG)
 336         return -EINVAL;
 337     k = &sigact_table[sig - 1];
 338 #if defined(DEBUG_SIGNAL) && 0
 339     fprintf(stderr, "sigaction sig=%d act=0x%08x, oact=0x%08x\n",
 340             sig, (int)act, (int)oact);
 341 #endif
 342     if (oact) {
 343         oact->_sa_handler = tswapl(k->sa._sa_handler);
 344         oact->sa_flags = tswapl(k->sa.sa_flags);
 345         oact->sa_restorer = tswapl(k->sa.sa_restorer);
 346         oact->sa_mask = k->sa.sa_mask;
 347     }
 348     if (act) {
 349         k->sa._sa_handler = tswapl(act->_sa_handler);
 350         k->sa.sa_flags = tswapl(act->sa_flags);
 351         k->sa.sa_restorer = tswapl(act->sa_restorer);
 352         k->sa.sa_mask = act->sa_mask;
 353     }
 354     return 0;
 355 }
 356
 357 #ifdef TARGET_I386
 358
 359 /* from the Linux kernel */
 360
 361 struct target_fpreg {
 362         uint16_t significand[4];
 363         uint16_t exponent;
 364 };
 365
 366 struct target_fpxreg {
 367         uint16_t significand[4];
 368         uint16_t exponent;
 369         uint16_t padding[3];
 370 };
 371
 372 struct target_xmmreg {
 373         target_ulong element[4];
 374 };
 375
 376 struct target_fpstate {
 377         /* Regular FPU environment */
 378         target_ulong    cw;
 379         target_ulong    sw;
 380         target_ulong    tag;
 381         target_ulong    ipoff;
 382         target_ulong    cssel;
 383         target_ulong    dataoff;
 384         target_ulong    datasel;
 385         struct target_fpreg     _st[8];
 386         uint16_t        status;
 387         uint16_t        magic;          /* 0xffff = regular FPU data only */
 388
 389         /* FXSR FPU environment */
 390         target_ulong    _fxsr_env[6];   /* FXSR FPU env is ignored */
 391         target_ulong    mxcsr;
 392         target_ulong    reserved;
 393         struct target_fpxreg    _fxsr_st[8];    /* FXSR FPU reg data is ignored */
 394         struct target_xmmreg    _xmm[8];
 395         target_ulong    padding[56];
 396 };
 397
 398 #define X86_FXSR_MAGIC          0x0000
 399
 400 struct target_sigcontext {
 401         uint16_t gs, __gsh;
 402         uint16_t fs, __fsh;
 403         uint16_t es, __esh;
 404         uint16_t ds, __dsh;
 405         target_ulong edi;
 406         target_ulong esi;
 407         target_ulong ebp;
 408         target_ulong esp;
 409         target_ulong ebx;
 410         target_ulong edx;
 411         target_ulong ecx;
 412         target_ulong eax;
 413         target_ulong trapno;
 414         target_ulong err;
 415         target_ulong eip;
 416         uint16_t cs, __csh;
 417         target_ulong eflags;
 418         target_ulong esp_at_signal;
 419         uint16_t ss, __ssh;
 420         target_ulong fpstate; /* pointer */
 421         target_ulong oldmask;
 422         target_ulong cr2;
 423 };
 424
 425 typedef struct target_sigaltstack {
 426         target_ulong ss_sp;
 427         int ss_flags;
 428         target_ulong ss_size;
 429 } target_stack_t;
 430
 431 struct target_ucontext {
 432         target_ulong      uc_flags;
 433         target_ulong      uc_link;
 434         target_stack_t    uc_stack;
 435         struct target_sigcontext uc_mcontext;
 436         target_sigset_t   uc_sigmask;   /* mask last for extensibility */
 437 };
 438
 439 struct sigframe
 440 {
 441     target_ulong pretcode;
 442     int sig;
 443     struct target_sigcontext sc;
 444     struct target_fpstate fpstate;
 445     target_ulong extramask[TARGET_NSIG_WORDS-1];
 446     char retcode[8];
 447 };
 448
 449 struct rt_sigframe
 450 {
 451     target_ulong pretcode;
 452     int sig;
 453     target_ulong pinfo;
 454     target_ulong puc;
 455     struct target_siginfo info;
 456     struct target_ucontext uc;
 457     struct target_fpstate fpstate;
 458     char retcode[8];
 459 };
 460
 461 /*
 462  * Set up a signal frame.
 463  */
 464
 465 #define __put_user(x,ptr)\
 466 ({\
 467     int size = sizeof(*ptr);\
 468     switch(size) {\
 469     case 1:\
 470         stb(ptr, (typeof(*ptr))(x));\
 471         break;\
 472     case 2:\
 473         stw(ptr, (typeof(*ptr))(x));\
 474         break;\
 475     case 4:\
 476         stl(ptr, (typeof(*ptr))(x));\
 477         break;\
 478     case 8:\
 479         stq(ptr, (typeof(*ptr))(x));\
 480         break;\
 481     default:\
 482         abort();\
 483     }\
 484     0;\
 485 })
 486
 487 #define get_user(val, ptr) (typeof(*ptr))(*(ptr))
 488
 489
 490 #define __copy_to_user(dst, src, size)\
 491 ({\
 492     memcpy(dst, src, size);\
 493     0;\
 494 })
 495
 496 static inline int copy_siginfo_to_user(target_siginfo_t *tinfo,
 497                                        const target_siginfo_t *info)
 498 {
 499     tswap_siginfo(tinfo, info);
 500     return 0;
 501 }
 502
 503 /* XXX: save x87 state */
 504 static int
 505 setup_sigcontext(struct target_sigcontext *sc, struct target_fpstate *fpstate,
 506                  CPUX86State *env, unsigned long mask)
 507 {
 508         int err = 0;
 509
 510         err |= __put_user(env->segs[R_GS], (unsigned int *)&sc->gs);
 511         err |= __put_user(env->segs[R_FS], (unsigned int *)&sc->fs);
 512         err |= __put_user(env->segs[R_ES], (unsigned int *)&sc->es);
 513         err |= __put_user(env->segs[R_DS], (unsigned int *)&sc->ds);
 514         err |= __put_user(env->regs[R_EDI], &sc->edi);
 515         err |= __put_user(env->regs[R_ESI], &sc->esi);
 516         err |= __put_user(env->regs[R_EBP], &sc->ebp);
 517         err |= __put_user(env->regs[R_ESP], &sc->esp);
 518         err |= __put_user(env->regs[R_EBX], &sc->ebx);
 519         err |= __put_user(env->regs[R_EDX], &sc->edx);
 520         err |= __put_user(env->regs[R_ECX], &sc->ecx);
 521         err |= __put_user(env->regs[R_EAX], &sc->eax);
 522         err |= __put_user(/*current->thread.trap_no*/ 0, &sc->trapno);
 523         err |= __put_user(/*current->thread.error_code*/ 0, &sc->err);
 524         err |= __put_user(env->eip, &sc->eip);
 525         err |= __put_user(env->segs[R_CS], (unsigned int *)&sc->cs);
 526         err |= __put_user(env->eflags, &sc->eflags);
 527         err |= __put_user(env->regs[R_ESP], &sc->esp_at_signal);
 528         err |= __put_user(env->segs[R_SS], (unsigned int *)&sc->ss);
 529 #if 0
 530         tmp = save_i387(fpstate);
 531         if (tmp < 0)
 532           err = 1;
 533         else
 534           err |= __put_user(tmp ? fpstate : NULL, &sc->fpstate);
 535 #else
 536         err |= __put_user(0, &sc->fpstate);
 537 #endif
 538         /* non-iBCS2 extensions.. */
 539         err |= __put_user(mask, &sc->oldmask);
 540         err |= __put_user(/*current->thread.cr2*/ 0, &sc->cr2);
 541         return err;
 542 }
 543
 544 /*
 545  * Determine which stack to use..
 546  */
 547
 548 static inline void *
 549 get_sigframe(struct emulated_sigaction *ka, CPUX86State *env, size_t frame_size)
 550 {
 551         unsigned long esp;
 552
 553         /* Default to using normal stack */
 554         esp = env->regs[R_ESP];
 555 #if 0
 556         /* This is the X/Open sanctioned signal stack switching.  */
 557         if (ka->sa.sa_flags & SA_ONSTACK) {
 558                 if (sas_ss_flags(esp) == 0)
 559                         esp = current->sas_ss_sp + current->sas_ss_size;
 560         }
 561
 562         /* This is the legacy signal stack switching. */
 563         else if ((regs->xss & 0xffff) != __USER_DS &&
 564                  !(ka->sa.sa_flags & SA_RESTORER) &&
 565                  ka->sa.sa_restorer) {
 566                 esp = (unsigned long) ka->sa.sa_restorer;
 567         }
 568 #endif
 569         return (void *)((esp - frame_size) & -8ul);
 570 }
 571
 572 static void setup_frame(int sig, struct emulated_sigaction *ka,
 573                         target_sigset_t *set, CPUX86State *env)
 574 {
 575         struct sigframe *frame;
 576         int err = 0;
 577
 578         frame = get_sigframe(ka, env, sizeof(*frame));
 579
 580 #if 0
 581         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 582                 goto give_sigsegv;
 583 #endif
 584         err |= __put_user((/*current->exec_domain
 585                            && current->exec_domain->signal_invmap
 586                            && sig < 32
 587                            ? current->exec_domain->signal_invmap[sig]
 588                            : */ sig),
 589                           &frame->sig);
 590         if (err)
 591                 goto give_sigsegv;
 592
 593         setup_sigcontext(&frame->sc, &frame->fpstate, env, set->sig[0]);
 594         if (err)
 595                 goto give_sigsegv;
 596
 597         if (TARGET_NSIG_WORDS > 1) {
 598                 err |= __copy_to_user(frame->extramask, &set->sig[1],
 599                                       sizeof(frame->extramask));
 600         }
 601         if (err)
 602                 goto give_sigsegv;
 603
 604         /* Set up to return from userspace.  If provided, use a stub
 605            already in userspace.  */
 606         if (ka->sa.sa_flags & TARGET_SA_RESTORER) {
 607                 err |= __put_user(ka->sa.sa_restorer, &frame->pretcode);
 608         } else {
 609                 err |= __put_user(frame->retcode, &frame->pretcode);
 610                 /* This is popl %eax ; movl $,%eax ; int $0x80 */
 611                 err |= __put_user(0xb858, (short *)(frame->retcode+0));
 612                 err |= __put_user(TARGET_NR_sigreturn, (int *)(frame->retcode+2));
 613                 err |= __put_user(0x80cd, (short *)(frame->retcode+6));
 614         }
 615
 616         if (err)
 617                 goto give_sigsegv;
 618
 619         /* Set up registers for signal handler */
 620         env->regs[R_ESP] = (unsigned long) frame;
 621         env->eip = (unsigned long) ka->sa._sa_handler;
 622
 623         cpu_x86_load_seg(env, R_DS, __USER_DS);
 624         cpu_x86_load_seg(env, R_ES, __USER_DS);
 625         cpu_x86_load_seg(env, R_SS, __USER_DS);
 626         cpu_x86_load_seg(env, R_CS, __USER_CS);
 627         env->eflags &= ~TF_MASK;
 628
 629         return;
 630
 631 give_sigsegv:
 632         if (sig == TARGET_SIGSEGV)
 633                 ka->sa._sa_handler = TARGET_SIG_DFL;
 634         force_sig(TARGET_SIGSEGV /* , current */);
 635 }
 636
 637 static void setup_rt_frame(int sig, struct emulated_sigaction *ka,
 638                            target_siginfo_t *info,
 639                            target_sigset_t *set, CPUX86State *env)
 640 {
 641         struct rt_sigframe *frame;
 642         int err = 0;
 643
 644         frame = get_sigframe(ka, env, sizeof(*frame));
 645
 646 #if 0
 647         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 648                 goto give_sigsegv;
 649 #endif
 650
 651         err |= __put_user((/*current->exec_domain
 652                            && current->exec_domain->signal_invmap
 653                            && sig < 32
 654                            ? current->exec_domain->signal_invmap[sig]
 655                            : */sig),
 656                           &frame->sig);
 657         err |= __put_user((target_ulong)&frame->info, &frame->pinfo);
 658         err |= __put_user((target_ulong)&frame->uc, &frame->puc);
 659         err |= copy_siginfo_to_user(&frame->info, info);
 660         if (err)
 661                 goto give_sigsegv;
 662
 663         /* Create the ucontext.  */
 664         err |= __put_user(0, &frame->uc.uc_flags);
 665         err |= __put_user(0, &frame->uc.uc_link);
 666         err |= __put_user(/*current->sas_ss_sp*/ 0, &frame->uc.uc_stack.ss_sp);
 667         err |= __put_user(/* sas_ss_flags(regs->esp) */ 0,
 668                           &frame->uc.uc_stack.ss_flags);
 669         err |= __put_user(/* current->sas_ss_size */ 0, &frame->uc.uc_stack.ss_size);
 670         err |= setup_sigcontext(&frame->uc.uc_mcontext, &frame->fpstate,
 671                                 env, set->sig[0]);
 672         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 673         if (err)
 674                 goto give_sigsegv;
 675
 676         /* Set up to return from userspace.  If provided, use a stub
 677            already in userspace.  */
 678         if (ka->sa.sa_flags & TARGET_SA_RESTORER) {
 679                 err |= __put_user(ka->sa.sa_restorer, &frame->pretcode);
 680         } else {
 681                 err |= __put_user(frame->retcode, &frame->pretcode);
 682                 /* This is movl $,%eax ; int $0x80 */
 683                 err |= __put_user(0xb8, (char *)(frame->retcode+0));
 684                 err |= __put_user(TARGET_NR_rt_sigreturn, (int *)(frame->retcode+1));
 685                 err |= __put_user(0x80cd, (short *)(frame->retcode+5));
 686         }
 687
 688         if (err)
 689                 goto give_sigsegv;
 690
 691         /* Set up registers for signal handler */
 692         env->regs[R_ESP] = (unsigned long) frame;
 693         env->eip = (unsigned long) ka->sa._sa_handler;
 694
 695         cpu_x86_load_seg(env, R_DS, __USER_DS);
 696         cpu_x86_load_seg(env, R_ES, __USER_DS);
 697         cpu_x86_load_seg(env, R_SS, __USER_DS);
 698         cpu_x86_load_seg(env, R_CS, __USER_CS);
 699         env->eflags &= ~TF_MASK;
 700
 701         return;
 702
 703 give_sigsegv:
 704         if (sig == TARGET_SIGSEGV)
 705                 ka->sa._sa_handler = TARGET_SIG_DFL;
 706         force_sig(TARGET_SIGSEGV /* , current */);
 707 }
 708
 709 static int
 710 restore_sigcontext(CPUX86State *env, struct target_sigcontext *sc, int *peax)
 711 {
 712         unsigned int err = 0;
 713
 714
 715
 716 #define COPY(x)         err |= __get_user(regs->x, &sc->x)
 717
 718 #define COPY_SEG(seg)                                                   \
 719         { unsigned short tmp;                                           \
 720           err |= __get_user(tmp, &sc->seg);                             \
 721           regs->x##seg = tmp; }
 722
 723 #define COPY_SEG_STRICT(seg)                                            \
 724         { unsigned short tmp;                                           \
 725           err |= __get_user(tmp, &sc->seg);                             \
 726           regs->x##seg = tmp|3; }
 727
 728 #define GET_SEG(seg)                                                    \
 729         { unsigned short tmp;                                           \
 730           err |= __get_user(tmp, &sc->seg);                             \
 731           loadsegment(seg,tmp); }
 732
 733         cpu_x86_load_seg(env, R_GS, lduw(&sc->gs));
 734         cpu_x86_load_seg(env, R_FS, lduw(&sc->fs));
 735         cpu_x86_load_seg(env, R_ES, lduw(&sc->es));
 736         cpu_x86_load_seg(env, R_DS, lduw(&sc->ds));
 737
 738         env->regs[R_EDI] = ldl(&sc->edi);
 739         env->regs[R_ESI] = ldl(&sc->esi);
 740         env->regs[R_EBP] = ldl(&sc->ebp);
 741         env->regs[R_ESP] = ldl(&sc->esp);
 742         env->regs[R_EBX] = ldl(&sc->ebx);
 743         env->regs[R_EDX] = ldl(&sc->edx);
 744         env->regs[R_ECX] = ldl(&sc->ecx);
 745         env->eip = ldl(&sc->eip);
 746
 747         cpu_x86_load_seg(env, R_CS, lduw(&sc->cs) | 3);
 748         cpu_x86_load_seg(env, R_SS, lduw(&sc->ss) | 3);
 749
 750         {
 751                 unsigned int tmpflags;
 752                 tmpflags = ldl(&sc->eflags);
 753                 env->eflags = (env->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);
 754                 //              regs->orig_eax = -1;            /* disable syscall checks */
 755         }
 756
 757 #if 0
 758         {
 759                 struct _fpstate * buf;
 760                 err |= __get_user(buf, &sc->fpstate);
 761                 if (buf) {
 762                         if (verify_area(VERIFY_READ, buf, sizeof(*buf)))
 763                                 goto badframe;
 764                         err |= restore_i387(buf);
 765                 }
 766         }
 767 #endif
 768         *peax = ldl(&sc->eax);
 769         return err;
 770 #if 0
 771 badframe:
 772         return 1;
 773 #endif
 774 }
 775
 776 long do_sigreturn(CPUX86State *env)
 777 {
 778     struct sigframe *frame = (struct sigframe *)(env->regs[R_ESP] - 8);
 779     target_sigset_t target_set;
 780     sigset_t set;
 781     int eax, i;
 782
 783     /* set blocked signals */
 784     target_set.sig[0] = frame->sc.oldmask;
 785     for(i = 1; i < TARGET_NSIG_WORDS; i++)
 786         target_set.sig[i] = frame->extramask[i - 1];
 787
 788     target_to_host_sigset(&set, &target_set);
 789     sigprocmask(SIG_SETMASK, &set, NULL);
 790
 791     /* restore registers */
 792     if (restore_sigcontext(env, &frame->sc, &eax))
 793         goto badframe;
 794     return eax;
 795
 796 badframe:
 797     force_sig(TARGET_SIGSEGV);
 798     return 0;
 799 }
 800
 801 long do_rt_sigreturn(CPUX86State *env)
 802 {
 803         struct rt_sigframe *frame = (struct rt_sigframe *)(env->regs[R_ESP] - 4);
 804         target_sigset_t target_set;
 805         sigset_t set;
 806         //      stack_t st;
 807         int eax;
 808
 809 #if 0
 810         if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
 811                 goto badframe;
 812 #endif
 813         memcpy(&target_set, &frame->uc.uc_sigmask, sizeof(target_sigset_t));
 814
 815         target_to_host_sigset(&set, &target_set);
 816         sigprocmask(SIG_SETMASK, &set, NULL);
 817
 818         if (restore_sigcontext(env, &frame->uc.uc_mcontext, &eax))
 819                 goto badframe;
 820
 821 #if 0
 822         if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
 823                 goto badframe;
 824         /* It is more difficult to avoid calling this function than to
 825            call it and ignore errors.  */
 826         do_sigaltstack(&st, NULL, regs->esp);
 827 #endif
 828         return eax;
 829
 830 badframe:
 831         force_sig(TARGET_SIGSEGV);
 832         return 0;
 833 }
 834
 835 #endif
 836
 837 void process_pending_signals(void *cpu_env)
 838 {
 839     int sig;
 840     target_ulong handler;
 841     sigset_t set, old_set;
 842     target_sigset_t target_old_set;
 843     struct emulated_sigaction *k;
 844     struct sigqueue *q;
 845
 846     if (!signal_pending)
 847         return;
 848
 849     k = sigact_table;
 850     for(sig = 1; sig <= TARGET_NSIG; sig++) {
 851         if (k->pending)
 852             goto handle_signal;
 853         k++;
 854     }
 855     /* if no signal is pending, just return */
 856     signal_pending = 0;
 857     return;
 858
 859  handle_signal:
 860 #ifdef DEBUG_SIGNAL
 861     fprintf(stderr, "qemu: process signal %d\n", sig);
 862 #endif
 863     /* dequeue signal */
 864     q = k->first;
 865     k->first = q->next;
 866     if (!k->first)
 867         k->pending = 0;
 868
 869     handler = k->sa._sa_handler;
 870     if (handler == TARGET_SIG_DFL) {
 871         /* default handler : ignore some signal. The other are fatal */
 872         if (sig != TARGET_SIGCHLD &&
 873             sig != TARGET_SIGURG &&
 874             sig != TARGET_SIGWINCH) {
 875             force_sig(sig);
 876         }
 877     } else if (handler == TARGET_SIG_IGN) {
 878         /* ignore sig */
 879     } else if (handler == TARGET_SIG_ERR) {
 880         force_sig(sig);
 881     } else {
 882         /* compute the blocked signals during the handler execution */
 883         target_to_host_sigset(&set, &k->sa.sa_mask);
 884         /* SA_NODEFER indicates that the current signal should not be
 885            blocked during the handler */
 886         if (!(k->sa.sa_flags & TARGET_SA_NODEFER))
 887             sigaddset(&set, target_to_host_signal(sig));
 888
 889         /* block signals in the handler using Linux */
 890         sigprocmask(SIG_BLOCK, &set, &old_set);
 891         /* save the previous blocked signal state to restore it at the
 892            end of the signal execution (see do_sigreturn) */
 893         host_to_target_sigset(&target_old_set, &old_set);
 894
 895         /* if the CPU is in VM86 mode, we restore the 32 bit values */
 896 #ifdef TARGET_I386
 897         {
 898             CPUX86State *env = cpu_env;
 899             if (env->eflags & VM_MASK)
 900                 save_v86_state(env);
 901         }
 902 #endif
 903         /* prepare the stack frame of the virtual CPU */
 904         if (k->sa.sa_flags & TARGET_SA_SIGINFO)
 905             setup_rt_frame(sig, k, &q->info, &target_old_set, cpu_env);
 906         else
 907             setup_frame(sig, k, &target_old_set, cpu_env);
 908         if (k->sa.sa_flags & TARGET_SA_RESETHAND)
 909             k->sa._sa_handler = TARGET_SIG_DFL;
 910     }
 911     if (q != &k->info)
 912         free_sigqueue(q);
 913 }
 914
 915