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, "gemu: 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_sigal: 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, "gemu: 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
 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, "gemu: 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         /* prepare the stack frame of the virtual CPU */
 897         if (k->sa.sa_flags & TARGET_SA_SIGINFO)
 898             setup_rt_frame(sig, k, &q->info, &target_old_set, cpu_env);
 899         else
 900             setup_frame(sig, k, &target_old_set, cpu_env);
 901         if (k->sa.sa_flags & TARGET_SA_RESETHAND)
 902             k->sa._sa_handler = TARGET_SIG_DFL;
 903     }
 904     if (q != &k->info)
 905         free_sigqueue(q);
 906 }
 907
 908