git.maemo.org Git - qemu/blob - darwin-user/signal.c

   1 /*
   2  *  Emulation of Linux signals
   3  *
   4  *  Copyright (c) 2003 Fabrice Bellard
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <stdarg.h>
  24 #include <unistd.h>
  25 #include <signal.h>
  26 #include <errno.h>
  27 #include <sys/ucontext.h>
  28
  29 #ifdef __ia64__
  30 #undef uc_mcontext
  31 #undef uc_sigmask
  32 #undef uc_stack
  33 #undef uc_link
  34 #endif
  35
  36 #include <signal.h>
  37
  38 #include "qemu.h"
  39
  40 #define DEBUG_SIGNAL
  41
  42 #define MAX_SIGQUEUE_SIZE 1024
  43
  44 struct sigqueue {
  45     struct sigqueue *next;
  46     target_siginfo_t info;
  47 };
  48
  49 struct emulated_sigaction {
  50     struct target_sigaction sa;
  51     int pending; /* true if signal is pending */
  52     struct sigqueue *first;
  53     struct sigqueue info; /* in order to always have memory for the
  54                              first signal, we put it here */
  55 };
  56
  57 static struct sigaltstack target_sigaltstack_used = {
  58     0, 0, SA_DISABLE
  59 };
  60
  61 static struct emulated_sigaction sigact_table[NSIG];
  62 static struct sigqueue sigqueue_table[MAX_SIGQUEUE_SIZE]; /* siginfo queue */
  63 static struct sigqueue *first_free; /* first free siginfo queue entry */
  64 static int signal_pending; /* non zero if a signal may be pending */
  65
  66 static void host_signal_handler(int host_signum, siginfo_t *info,
  67                                 void *puc);
  68
  69
  70 static inline int host_to_target_signal(int sig)
  71 {
  72     return sig;
  73 }
  74
  75 static inline int target_to_host_signal(int sig)
  76 {
  77     return sig;
  78 }
  79
  80 /* siginfo conversion */
  81
  82
  83
  84 void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info)
  85 {
  86
  87 }
  88
  89 void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo)
  90 {
  91
  92 }
  93
  94 void signal_init(void)
  95 {
  96     struct sigaction act;
  97     int i;
  98
  99     /* set all host signal handlers. ALL signals are blocked during
 100        the handlers to serialize them. */
 101     sigfillset(&act.sa_mask);
 102     act.sa_flags = SA_SIGINFO;
 103     act.sa_sigaction = host_signal_handler;
 104     for(i = 1; i < NSIG; i++) {
 105         sigaction(i, &act, NULL);
 106     }
 107
 108     memset(sigact_table, 0, sizeof(sigact_table));
 109
 110     first_free = &sigqueue_table[0];
 111     for(i = 0; i < MAX_SIGQUEUE_SIZE - 1; i++)
 112         sigqueue_table[i].next = &sigqueue_table[i + 1];
 113     sigqueue_table[MAX_SIGQUEUE_SIZE - 1].next = NULL;
 114 }
 115
 116 /* signal queue handling */
 117
 118 static inline struct sigqueue *alloc_sigqueue(void)
 119 {
 120     struct sigqueue *q = first_free;
 121     if (!q)
 122         return NULL;
 123     first_free = q->next;
 124     return q;
 125 }
 126
 127 static inline void free_sigqueue(struct sigqueue *q)
 128 {
 129     q->next = first_free;
 130     first_free = q;
 131 }
 132
 133 /* abort execution with signal */
 134 void __attribute((noreturn)) force_sig(int sig)
 135 {
 136     int host_sig;
 137     host_sig = target_to_host_signal(sig);
 138     fprintf(stderr, "qemu: uncaught target signal %d (%s) - exiting\n",
 139             sig, strsignal(host_sig));
 140     _exit(-host_sig);
 141 }
 142
 143 /* queue a signal so that it will be send to the virtual CPU as soon
 144    as possible */
 145 int queue_signal(int sig, target_siginfo_t *info)
 146 {
 147     struct emulated_sigaction *k;
 148     struct sigqueue *q, **pq;
 149     target_ulong handler;
 150
 151 #if defined(DEBUG_SIGNAL)
 152     fprintf(stderr, "queue_signal: sig=%d\n",
 153             sig);
 154 #endif
 155     k = &sigact_table[sig - 1];
 156     handler = (target_ulong)k->sa.sa_handler;
 157     if (handler == SIG_DFL) {
 158         /* default handler : ignore some signal. The other are fatal */
 159         if (sig != SIGCHLD &&
 160             sig != SIGURG &&
 161             sig != SIGWINCH) {
 162             force_sig(sig);
 163         } else {
 164             return 0; /* indicate ignored */
 165         }
 166     } else if (handler == host_to_target_signal(SIG_IGN)) {
 167         /* ignore signal */
 168         return 0;
 169     } else if (handler == host_to_target_signal(SIG_ERR)) {
 170         force_sig(sig);
 171     } else {
 172         pq = &k->first;
 173         if (!k->pending) {
 174             /* first signal */
 175             q = &k->info;
 176         } else {
 177             q = alloc_sigqueue();
 178             if (!q)
 179                 return -EAGAIN;
 180             while (*pq != NULL)
 181                 pq = &(*pq)->next;
 182         }
 183         *pq = q;
 184         q->info = *info;
 185         q->next = NULL;
 186         k->pending = 1;
 187         /* signal that a new signal is pending */
 188         signal_pending = 1;
 189         return 1; /* indicates that the signal was queued */
 190     }
 191 }
 192
 193 static void host_signal_handler(int host_signum, siginfo_t *info,
 194                                 void *puc)
 195 {
 196     int sig;
 197     target_siginfo_t tinfo;
 198
 199     /* the CPU emulator uses some host signals to detect exceptions,
 200        we we forward to it some signals */
 201     if (host_signum == SIGSEGV || host_signum == SIGBUS) {
 202         if (cpu_signal_handler(host_signum, (void*)info, puc))
 203             return;
 204     }
 205
 206     /* get target signal number */
 207     sig = host_to_target_signal(host_signum);
 208     if (sig < 1 || sig > NSIG)
 209         return;
 210
 211 #if defined(DEBUG_SIGNAL)
 212         fprintf(stderr, "qemu: got signal %d\n", sig);
 213 #endif
 214     if (queue_signal(sig, &tinfo) == 1) {
 215         /* interrupt the virtual CPU as soon as possible */
 216         cpu_interrupt(global_env, CPU_INTERRUPT_EXIT);
 217     }
 218 }
 219
 220 int do_sigaltstack(const struct sigaltstack *ss, struct sigaltstack *oss)
 221 {
 222     /* XXX: test errors */
 223     if(oss)
 224     {
 225         oss->ss_sp = tswap32(target_sigaltstack_used.ss_sp);
 226         oss->ss_size = tswap32(target_sigaltstack_used.ss_size);
 227         oss->ss_flags = tswap32(target_sigaltstack_used.ss_flags);
 228     }
 229     if(ss)
 230     {
 231         target_sigaltstack_used.ss_sp = tswap32(ss->ss_sp);
 232         target_sigaltstack_used.ss_size = tswap32(ss->ss_size);
 233         target_sigaltstack_used.ss_flags = tswap32(ss->ss_flags);
 234     }
 235     return 0;
 236 }
 237
 238 int do_sigaction(int sig, const struct sigaction *act,
 239                  struct sigaction *oact)
 240 {
 241     struct emulated_sigaction *k;
 242     struct sigaction act1;
 243     int host_sig;
 244
 245     if (sig < 1 || sig > NSIG)
 246         return -EINVAL;
 247
 248     k = &sigact_table[sig - 1];
 249 #if defined(DEBUG_SIGNAL)
 250     fprintf(stderr, "sigaction 1 sig=%d act=0x%08x, oact=0x%08x\n",
 251             sig, (int)act, (int)oact);
 252 #endif
 253     if (oact) {
 254 #if defined(DEBUG_SIGNAL)
 255     fprintf(stderr, "sigaction 1 sig=%d act=0x%08x, oact=0x%08x\n",
 256             sig, (int)act, (int)oact);
 257 #endif
 258
 259         oact->sa_handler = tswapl(k->sa.sa_handler);
 260         oact->sa_flags = tswapl(k->sa.sa_flags);
 261         oact->sa_mask = tswapl(k->sa.sa_mask);
 262     }
 263     if (act) {
 264 #if defined(DEBUG_SIGNAL)
 265     fprintf(stderr, "sigaction handler 0x%x flag 0x%x mask 0x%x\n",
 266             act->sa_handler, act->sa_flags, act->sa_mask);
 267 #endif
 268
 269         k->sa.sa_handler = tswapl(act->sa_handler);
 270         k->sa.sa_flags = tswapl(act->sa_flags);
 271         k->sa.sa_mask = tswapl(act->sa_mask);
 272         /* we update the host signal state */
 273         host_sig = target_to_host_signal(sig);
 274         if (host_sig != SIGSEGV && host_sig != SIGBUS) {
 275 #if defined(DEBUG_SIGNAL)
 276     fprintf(stderr, "sigaction handler going to call sigaction\n",
 277             act->sa_handler, act->sa_flags, act->sa_mask);
 278 #endif
 279
 280             sigfillset(&act1.sa_mask);
 281             act1.sa_flags = SA_SIGINFO;
 282             if (k->sa.sa_flags & SA_RESTART)
 283                 act1.sa_flags |= SA_RESTART;
 284             /* NOTE: it is important to update the host kernel signal
 285                ignore state to avoid getting unexpected interrupted
 286                syscalls */
 287             if (k->sa.sa_handler == SIG_IGN) {
 288                 act1.sa_sigaction = (void *)SIG_IGN;
 289             } else if (k->sa.sa_handler == SIG_DFL) {
 290                 act1.sa_sigaction = (void *)SIG_DFL;
 291             } else {
 292                 act1.sa_sigaction = host_signal_handler;
 293             }
 294             sigaction(host_sig, &act1, NULL);
 295         }
 296     }
 297     return 0;
 298 }
 299
 300
 301 #ifdef TARGET_I386
 302
 303 static inline void *
 304 get_sigframe(struct emulated_sigaction *ka, CPUX86State *env, size_t frame_size)
 305 {
 306     /* XXX Fix that */
 307     if(target_sigaltstack_used.ss_flags & SA_DISABLE)
 308     {
 309         int esp;
 310         /* Default to using normal stack */
 311         esp = env->regs[R_ESP];
 312
 313         return (void *)((esp - frame_size) & -8ul);
 314     }
 315     else
 316     {
 317         return target_sigaltstack_used.ss_sp;
 318     }
 319 }
 320
 321 static void setup_frame(int sig, struct emulated_sigaction *ka,
 322                         void *set, CPUState *env)
 323 {
 324         void *frame;
 325         int i, err = 0;
 326
 327     fprintf(stderr, "setup_frame %d\n", sig);
 328         frame = get_sigframe(ka, env, sizeof(*frame));
 329
 330         /* Set up registers for signal handler */
 331         env->regs[R_ESP] = (unsigned long) frame;
 332         env->eip = (unsigned long) ka->sa.sa_handler;
 333
 334         env->eflags &= ~TF_MASK;
 335
 336         return;
 337
 338 give_sigsegv:
 339         if (sig == SIGSEGV)
 340                 ka->sa.sa_handler = SIG_DFL;
 341         force_sig(SIGSEGV /* , current */);
 342 }
 343
 344 long do_sigreturn(CPUState *env, int num)
 345 {
 346     int i = 0;
 347     struct target_sigcontext *scp = get_int_arg(&i, env);
 348     /* XXX Get current signal number */
 349     /* XXX Adjust accordin to sc_onstack, sc_mask */
 350     if(tswapl(scp->sc_onstack) & 0x1)
 351         target_sigaltstack_used.ss_flags |= ~SA_DISABLE;
 352     else
 353         target_sigaltstack_used.ss_flags &=  SA_DISABLE;
 354     int set = tswapl(scp->sc_eax);
 355     sigprocmask(SIG_SETMASK, &set, NULL);
 356
 357     fprintf(stderr, "do_sigreturn: partially implemented %x EAX:%x EBX:%x\n", scp->sc_mask, tswapl(scp->sc_eax), tswapl(scp->sc_ebx));
 358     fprintf(stderr, "ECX:%x EDX:%x EDI:%x\n", scp->sc_ecx, tswapl(scp->sc_edx), tswapl(scp->sc_edi));
 359     fprintf(stderr, "EIP:%x\n", tswapl(scp->sc_eip));
 360
 361     env->regs[R_EAX] = tswapl(scp->sc_eax);
 362     env->regs[R_EBX] = tswapl(scp->sc_ebx);
 363     env->regs[R_ECX] = tswapl(scp->sc_ecx);
 364     env->regs[R_EDX] = tswapl(scp->sc_edx);
 365     env->regs[R_EDI] = tswapl(scp->sc_edi);
 366     env->regs[R_ESI] = tswapl(scp->sc_esi);
 367     env->regs[R_EBP] = tswapl(scp->sc_ebp);
 368     env->regs[R_ESP] = tswapl(scp->sc_esp);
 369     env->segs[R_SS].selector = (void*)tswapl(scp->sc_ss);
 370     env->eflags = tswapl(scp->sc_eflags);
 371     env->eip = tswapl(scp->sc_eip);
 372     env->segs[R_CS].selector = (void*)tswapl(scp->sc_cs);
 373     env->segs[R_DS].selector = (void*)tswapl(scp->sc_ds);
 374     env->segs[R_ES].selector = (void*)tswapl(scp->sc_es);
 375     env->segs[R_FS].selector = (void*)tswapl(scp->sc_fs);
 376     env->segs[R_GS].selector = (void*)tswapl(scp->sc_gs);
 377
 378     /* Again, because our caller's caller will reset EAX */
 379     return env->regs[R_EAX];
 380 }
 381
 382 #else
 383
 384 static void setup_frame(int sig, struct emulated_sigaction *ka,
 385                         void *set, CPUState *env)
 386 {
 387     fprintf(stderr, "setup_frame: not implemented\n");
 388 }
 389
 390 long do_sigreturn(CPUState *env, int num)
 391 {
 392     int i = 0;
 393     struct target_sigcontext *scp = get_int_arg(&i, env);
 394     fprintf(stderr, "do_sigreturn: not implemented\n");
 395     return -ENOSYS;
 396 }
 397
 398 #endif
 399
 400 void process_pending_signals(void *cpu_env)
 401 {
 402     struct emulated_sigaction *k;
 403     struct sigqueue *q;
 404     target_ulong handler;
 405     int sig;
 406
 407     if (!signal_pending)
 408         return;
 409
 410     k = sigact_table;
 411
 412     for(sig = 1; sig <= NSIG; sig++) {
 413         if (k->pending)
 414             goto handle_signal;
 415         k++;
 416     }
 417
 418     /* if no signal is pending, just return */
 419     signal_pending = 0;
 420     return;
 421 handle_signal:
 422     #ifdef DEBUG_SIGNAL
 423     fprintf(stderr, "qemu: process signal %d\n", sig);
 424     #endif
 425     /* dequeue signal */
 426     q = k->first;
 427     k->first = q->next;
 428     if (!k->first)
 429         k->pending = 0;
 430
 431     sig = gdb_handlesig (cpu_env, sig);
 432     if (!sig) {
 433         fprintf (stderr, "Lost signal\n");
 434         abort();
 435     }
 436
 437     handler = k->sa.sa_handler;
 438     if (handler == SIG_DFL) {
 439         /* default handler : ignore some signal. The other are fatal */
 440         if (sig != SIGCHLD &&
 441             sig != SIGURG &&
 442             sig != SIGWINCH) {
 443             force_sig(sig);
 444         }
 445     } else if (handler == SIG_IGN) {
 446         /* ignore sig */
 447     } else if (handler == SIG_ERR) {
 448         force_sig(sig);
 449     } else {
 450
 451         setup_frame(sig, k, 0, cpu_env);
 452         if (k->sa.sa_flags & SA_RESETHAND)
 453             k->sa.sa_handler = SIG_DFL;
 454     }
 455     if (q != &k->info)
 456         free_sigqueue(q);
 457 }