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