linux-user/cris/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, see <http://www.gnu.org/licenses/>.
  18  */
  19 #include "qemu/osdep.h"
  20 #include "qemu.h"
  21 #include "user-internals.h"
  22 #include "signal-common.h"
  23 #include "linux-user/trace.h"
  24
  25 struct target_sigcontext {
  26     struct target_pt_regs regs;  /* needs to be first */
  27     uint32_t oldmask;
  28     uint32_t usp;    /* usp before stacking this gunk on it */
  29 };
  30
  31 /* Signal frames. */
  32 struct target_signal_frame {
  33     struct target_sigcontext sc;
  34     uint32_t extramask[TARGET_NSIG_WORDS - 1];
  35     uint16_t retcode[4];      /* Trampoline code. */
  36 };
  37
  38 struct rt_signal_frame {
  39     siginfo_t *pinfo;
  40     void *puc;
  41     siginfo_t info;
  42     ucontext_t uc;
  43     uint16_t retcode[4];      /* Trampoline code. */
  44 };
  45
  46 static void setup_sigcontext(struct target_sigcontext *sc, CPUCRISState *env)
  47 {
  48     __put_user(env->regs[0], &sc->regs.r0);
  49     __put_user(env->regs[1], &sc->regs.r1);
  50     __put_user(env->regs[2], &sc->regs.r2);
  51     __put_user(env->regs[3], &sc->regs.r3);
  52     __put_user(env->regs[4], &sc->regs.r4);
  53     __put_user(env->regs[5], &sc->regs.r5);
  54     __put_user(env->regs[6], &sc->regs.r6);
  55     __put_user(env->regs[7], &sc->regs.r7);
  56     __put_user(env->regs[8], &sc->regs.r8);
  57     __put_user(env->regs[9], &sc->regs.r9);
  58     __put_user(env->regs[10], &sc->regs.r10);
  59     __put_user(env->regs[11], &sc->regs.r11);
  60     __put_user(env->regs[12], &sc->regs.r12);
  61     __put_user(env->regs[13], &sc->regs.r13);
  62     __put_user(env->regs[14], &sc->usp);
  63     __put_user(env->regs[15], &sc->regs.acr);
  64     __put_user(env->pregs[PR_MOF], &sc->regs.mof);
  65     __put_user(env->pregs[PR_SRP], &sc->regs.srp);
  66     __put_user(env->pc, &sc->regs.erp);
  67 }
  68
  69 static void restore_sigcontext(struct target_sigcontext *sc, CPUCRISState *env)
  70 {
  71     __get_user(env->regs[0], &sc->regs.r0);
  72     __get_user(env->regs[1], &sc->regs.r1);
  73     __get_user(env->regs[2], &sc->regs.r2);
  74     __get_user(env->regs[3], &sc->regs.r3);
  75     __get_user(env->regs[4], &sc->regs.r4);
  76     __get_user(env->regs[5], &sc->regs.r5);
  77     __get_user(env->regs[6], &sc->regs.r6);
  78     __get_user(env->regs[7], &sc->regs.r7);
  79     __get_user(env->regs[8], &sc->regs.r8);
  80     __get_user(env->regs[9], &sc->regs.r9);
  81     __get_user(env->regs[10], &sc->regs.r10);
  82     __get_user(env->regs[11], &sc->regs.r11);
  83     __get_user(env->regs[12], &sc->regs.r12);
  84     __get_user(env->regs[13], &sc->regs.r13);
  85     __get_user(env->regs[14], &sc->usp);
  86     __get_user(env->regs[15], &sc->regs.acr);
  87     __get_user(env->pregs[PR_MOF], &sc->regs.mof);
  88     __get_user(env->pregs[PR_SRP], &sc->regs.srp);
  89     __get_user(env->pc, &sc->regs.erp);
  90 }
  91
  92 static abi_ulong get_sigframe(CPUCRISState *env, int framesize)
  93 {
  94     abi_ulong sp;
  95     /* Align the stack downwards to 4.  */
  96     sp = (env->regs[R_SP] & ~3);
  97     return sp - framesize;
  98 }
  99
 100 static void setup_sigreturn(uint16_t *retcode)
 101 {
 102     /* This is movu.w __NR_sigreturn, r9; break 13; */
 103     __put_user(0x9c5f, retcode + 0);
 104     __put_user(TARGET_NR_sigreturn, retcode + 1);
 105     __put_user(0xe93d, retcode + 2);
 106 }
 107
 108 void setup_frame(int sig, struct target_sigaction *ka,
 109                  target_sigset_t *set, CPUCRISState *env)
 110 {
 111     struct target_signal_frame *frame;
 112     abi_ulong frame_addr;
 113     int i;
 114
 115     frame_addr = get_sigframe(env, sizeof *frame);
 116     trace_user_setup_frame(env, frame_addr);
 117     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
 118         goto badframe;
 119
 120     /*
 121      * The CRIS signal return trampoline. A real linux/CRIS kernel doesn't
 122      * use this trampoline anymore but it sets it up for GDB.
 123      */
 124     setup_sigreturn(frame->retcode);
 125
 126     /* Save the mask.  */
 127     __put_user(set->sig[0], &frame->sc.oldmask);
 128
 129     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
 130         __put_user(set->sig[i], &frame->extramask[i - 1]);
 131     }
 132
 133     setup_sigcontext(&frame->sc, env);
 134
 135     /* Move the stack and setup the arguments for the handler.  */
 136     env->regs[R_SP] = frame_addr;
 137     env->regs[10] = sig;
 138     env->pc = (unsigned long) ka->_sa_handler;
 139     /* Link SRP so the guest returns through the trampoline.  */
 140     env->pregs[PR_SRP] = default_sigreturn;
 141
 142     unlock_user_struct(frame, frame_addr, 1);
 143     return;
 144 badframe:
 145     force_sigsegv(sig);
 146 }
 147
 148 void setup_rt_frame(int sig, struct target_sigaction *ka,
 149                     target_siginfo_t *info,
 150                      target_sigset_t *set, CPUCRISState *env)
 151 {
 152     qemu_log_mask(LOG_UNIMP, "setup_rt_frame: not implemented\n");
 153 }
 154
 155 long do_sigreturn(CPUCRISState *env)
 156 {
 157     struct target_signal_frame *frame;
 158     abi_ulong frame_addr;
 159     target_sigset_t target_set;
 160     sigset_t set;
 161     int i;
 162
 163     frame_addr = env->regs[R_SP];
 164     trace_user_do_sigreturn(env, frame_addr);
 165     /* Make sure the guest isn't playing games.  */
 166     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1)) {
 167         goto badframe;
 168     }
 169
 170     /* Restore blocked signals */
 171     __get_user(target_set.sig[0], &frame->sc.oldmask);
 172     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
 173         __get_user(target_set.sig[i], &frame->extramask[i - 1]);
 174     }
 175     target_to_host_sigset_internal(&set, &target_set);
 176     set_sigmask(&set);
 177
 178     restore_sigcontext(&frame->sc, env);
 179     unlock_user_struct(frame, frame_addr, 0);
 180     return -QEMU_ESIGRETURN;
 181 badframe:
 182     force_sig(TARGET_SIGSEGV);
 183     return -QEMU_ESIGRETURN;
 184 }
 185
 186 long do_rt_sigreturn(CPUCRISState *env)
 187 {
 188     trace_user_do_rt_sigreturn(env, 0);
 189     qemu_log_mask(LOG_UNIMP, "do_rt_sigreturn: not implemented\n");
 190     return -TARGET_ENOSYS;
 191 }
 192
 193 void setup_sigtramp(abi_ulong sigtramp_page)
 194 {
 195     uint16_t *tramp = lock_user(VERIFY_WRITE, sigtramp_page, 6, 0);
 196     assert(tramp != NULL);
 197
 198     default_sigreturn = sigtramp_page;
 199     setup_sigreturn(tramp);
 200
 201     unlock_user(tramp, sigtramp_page, 6);
 202 }