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