linux-user/m68k/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 "target_signal.h"
  22 #include "signal-common.h"
  23 #include "linux-user/trace.h"
  24
  25 struct target_sigcontext {
  26     abi_ulong  sc_mask;
  27     abi_ulong  sc_usp;
  28     abi_ulong  sc_d0;
  29     abi_ulong  sc_d1;
  30     abi_ulong  sc_a0;
  31     abi_ulong  sc_a1;
  32     unsigned short sc_sr;
  33     abi_ulong  sc_pc;
  34 };
  35
  36 struct target_sigframe
  37 {
  38     abi_ulong pretcode;
  39     int sig;
  40     int code;
  41     abi_ulong psc;
  42     char retcode[8];
  43     abi_ulong extramask[TARGET_NSIG_WORDS-1];
  44     struct target_sigcontext sc;
  45 };
  46
  47 typedef int target_greg_t;
  48 #define TARGET_NGREG 18
  49 typedef target_greg_t target_gregset_t[TARGET_NGREG];
  50
  51 typedef struct target_fpregset {
  52     int f_fpcntl[3];
  53     int f_fpregs[8*3];
  54 } target_fpregset_t;
  55
  56 struct target_mcontext {
  57     int version;
  58     target_gregset_t gregs;
  59     target_fpregset_t fpregs;
  60 };
  61
  62 #define TARGET_MCONTEXT_VERSION 2
  63
  64 struct target_ucontext {
  65     abi_ulong tuc_flags;
  66     abi_ulong tuc_link;
  67     target_stack_t tuc_stack;
  68     struct target_mcontext tuc_mcontext;
  69     abi_long tuc_filler[80];
  70     target_sigset_t tuc_sigmask;
  71 };
  72
  73 struct target_rt_sigframe
  74 {
  75     abi_ulong pretcode;
  76     int sig;
  77     abi_ulong pinfo;
  78     abi_ulong puc;
  79     char retcode[8];
  80     struct target_siginfo info;
  81     struct target_ucontext uc;
  82 };
  83
  84 static void setup_sigcontext(struct target_sigcontext *sc, CPUM68KState *env,
  85                              abi_ulong mask)
  86 {
  87     uint32_t sr = (env->sr & 0xff00) | cpu_m68k_get_ccr(env);
  88     __put_user(mask, &sc->sc_mask);
  89     __put_user(env->aregs[7], &sc->sc_usp);
  90     __put_user(env->dregs[0], &sc->sc_d0);
  91     __put_user(env->dregs[1], &sc->sc_d1);
  92     __put_user(env->aregs[0], &sc->sc_a0);
  93     __put_user(env->aregs[1], &sc->sc_a1);
  94     __put_user(sr, &sc->sc_sr);
  95     __put_user(env->pc, &sc->sc_pc);
  96 }
  97
  98 static void
  99 restore_sigcontext(CPUM68KState *env, struct target_sigcontext *sc)
 100 {
 101     int temp;
 102
 103     __get_user(env->aregs[7], &sc->sc_usp);
 104     __get_user(env->dregs[0], &sc->sc_d0);
 105     __get_user(env->dregs[1], &sc->sc_d1);
 106     __get_user(env->aregs[0], &sc->sc_a0);
 107     __get_user(env->aregs[1], &sc->sc_a1);
 108     __get_user(env->pc, &sc->sc_pc);
 109     __get_user(temp, &sc->sc_sr);
 110     cpu_m68k_set_ccr(env, temp);
 111 }
 112
 113 /*
 114  * Determine which stack to use..
 115  */
 116 static inline abi_ulong
 117 get_sigframe(struct target_sigaction *ka, CPUM68KState *regs,
 118              size_t frame_size)
 119 {
 120     abi_ulong sp;
 121
 122     sp = target_sigsp(get_sp_from_cpustate(regs), ka);
 123
 124
 125     return ((sp - frame_size) & -8UL);
 126 }
 127
 128 void setup_frame(int sig, struct target_sigaction *ka,
 129                  target_sigset_t *set, CPUM68KState *env)
 130 {
 131     struct target_sigframe *frame;
 132     abi_ulong frame_addr;
 133     abi_ulong retcode_addr;
 134     abi_ulong sc_addr;
 135     int i;
 136
 137     frame_addr = get_sigframe(ka, env, sizeof *frame);
 138     trace_user_setup_frame(env, frame_addr);
 139     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
 140         goto give_sigsegv;
 141     }
 142
 143     __put_user(sig, &frame->sig);
 144
 145     sc_addr = frame_addr + offsetof(struct target_sigframe, sc);
 146     __put_user(sc_addr, &frame->psc);
 147
 148     setup_sigcontext(&frame->sc, env, set->sig[0]);
 149
 150     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
 151         __put_user(set->sig[i], &frame->extramask[i - 1]);
 152     }
 153
 154     /* Set up to return from userspace.  */
 155
 156     retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode);
 157     __put_user(retcode_addr, &frame->pretcode);
 158
 159     /* moveq #,d0; trap #0 */
 160
 161     __put_user(0x70004e40 + (TARGET_NR_sigreturn << 16),
 162                (uint32_t *)(frame->retcode));
 163
 164     /* Set up to return from userspace */
 165
 166     env->aregs[7] = frame_addr;
 167     env->pc = ka->_sa_handler;
 168
 169     unlock_user_struct(frame, frame_addr, 1);
 170     return;
 171
 172 give_sigsegv:
 173     force_sigsegv(sig);
 174 }
 175
 176 static inline void target_rt_save_fpu_state(struct target_ucontext *uc,
 177                                            CPUM68KState *env)
 178 {
 179     int i;
 180     target_fpregset_t *fpregs = &uc->tuc_mcontext.fpregs;
 181
 182     __put_user(env->fpcr, &fpregs->f_fpcntl[0]);
 183     __put_user(env->fpsr, &fpregs->f_fpcntl[1]);
 184     /* fpiar is not emulated */
 185
 186     for (i = 0; i < 8; i++) {
 187         uint32_t high = env->fregs[i].d.high << 16;
 188         __put_user(high, &fpregs->f_fpregs[i * 3]);
 189         __put_user(env->fregs[i].d.low,
 190                    (uint64_t *)&fpregs->f_fpregs[i * 3 + 1]);
 191     }
 192 }
 193
 194 static inline int target_rt_setup_ucontext(struct target_ucontext *uc,
 195                                            CPUM68KState *env)
 196 {
 197     target_greg_t *gregs = uc->tuc_mcontext.gregs;
 198     uint32_t sr = (env->sr & 0xff00) | cpu_m68k_get_ccr(env);
 199
 200     __put_user(TARGET_MCONTEXT_VERSION, &uc->tuc_mcontext.version);
 201     __put_user(env->dregs[0], &gregs[0]);
 202     __put_user(env->dregs[1], &gregs[1]);
 203     __put_user(env->dregs[2], &gregs[2]);
 204     __put_user(env->dregs[3], &gregs[3]);
 205     __put_user(env->dregs[4], &gregs[4]);
 206     __put_user(env->dregs[5], &gregs[5]);
 207     __put_user(env->dregs[6], &gregs[6]);
 208     __put_user(env->dregs[7], &gregs[7]);
 209     __put_user(env->aregs[0], &gregs[8]);
 210     __put_user(env->aregs[1], &gregs[9]);
 211     __put_user(env->aregs[2], &gregs[10]);
 212     __put_user(env->aregs[3], &gregs[11]);
 213     __put_user(env->aregs[4], &gregs[12]);
 214     __put_user(env->aregs[5], &gregs[13]);
 215     __put_user(env->aregs[6], &gregs[14]);
 216     __put_user(env->aregs[7], &gregs[15]);
 217     __put_user(env->pc, &gregs[16]);
 218     __put_user(sr, &gregs[17]);
 219
 220     target_rt_save_fpu_state(uc, env);
 221
 222     return 0;
 223 }
 224
 225 static inline void target_rt_restore_fpu_state(CPUM68KState *env,
 226                                                struct target_ucontext *uc)
 227 {
 228     int i;
 229     target_fpregset_t *fpregs = &uc->tuc_mcontext.fpregs;
 230     uint32_t fpcr;
 231
 232     __get_user(fpcr, &fpregs->f_fpcntl[0]);
 233     cpu_m68k_set_fpcr(env, fpcr);
 234     __get_user(env->fpsr, &fpregs->f_fpcntl[1]);
 235     /* fpiar is not emulated */
 236
 237     for (i = 0; i < 8; i++) {
 238         uint32_t high;
 239         __get_user(high, &fpregs->f_fpregs[i * 3]);
 240         env->fregs[i].d.high = high >> 16;
 241         __get_user(env->fregs[i].d.low,
 242                    (uint64_t *)&fpregs->f_fpregs[i * 3 + 1]);
 243     }
 244 }
 245
 246 static inline int target_rt_restore_ucontext(CPUM68KState *env,
 247                                              struct target_ucontext *uc)
 248 {
 249     int temp;
 250     target_greg_t *gregs = uc->tuc_mcontext.gregs;
 251
 252     __get_user(temp, &uc->tuc_mcontext.version);
 253     if (temp != TARGET_MCONTEXT_VERSION)
 254         goto badframe;
 255
 256     /* restore passed registers */
 257     __get_user(env->dregs[0], &gregs[0]);
 258     __get_user(env->dregs[1], &gregs[1]);
 259     __get_user(env->dregs[2], &gregs[2]);
 260     __get_user(env->dregs[3], &gregs[3]);
 261     __get_user(env->dregs[4], &gregs[4]);
 262     __get_user(env->dregs[5], &gregs[5]);
 263     __get_user(env->dregs[6], &gregs[6]);
 264     __get_user(env->dregs[7], &gregs[7]);
 265     __get_user(env->aregs[0], &gregs[8]);
 266     __get_user(env->aregs[1], &gregs[9]);
 267     __get_user(env->aregs[2], &gregs[10]);
 268     __get_user(env->aregs[3], &gregs[11]);
 269     __get_user(env->aregs[4], &gregs[12]);
 270     __get_user(env->aregs[5], &gregs[13]);
 271     __get_user(env->aregs[6], &gregs[14]);
 272     __get_user(env->aregs[7], &gregs[15]);
 273     __get_user(env->pc, &gregs[16]);
 274     __get_user(temp, &gregs[17]);
 275     cpu_m68k_set_ccr(env, temp);
 276
 277     target_rt_restore_fpu_state(env, uc);
 278
 279     return 0;
 280
 281 badframe:
 282     return 1;
 283 }
 284
 285 void setup_rt_frame(int sig, struct target_sigaction *ka,
 286                     target_siginfo_t *info,
 287                     target_sigset_t *set, CPUM68KState *env)
 288 {
 289     struct target_rt_sigframe *frame;
 290     abi_ulong frame_addr;
 291     abi_ulong retcode_addr;
 292     abi_ulong info_addr;
 293     abi_ulong uc_addr;
 294     int err = 0;
 295     int i;
 296
 297     frame_addr = get_sigframe(ka, env, sizeof *frame);
 298     trace_user_setup_rt_frame(env, frame_addr);
 299     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
 300         goto give_sigsegv;
 301     }
 302
 303     __put_user(sig, &frame->sig);
 304
 305     info_addr = frame_addr + offsetof(struct target_rt_sigframe, info);
 306     __put_user(info_addr, &frame->pinfo);
 307
 308     uc_addr = frame_addr + offsetof(struct target_rt_sigframe, uc);
 309     __put_user(uc_addr, &frame->puc);
 310
 311     tswap_siginfo(&frame->info, info);
 312
 313     /* Create the ucontext */
 314
 315     __put_user(0, &frame->uc.tuc_flags);
 316     __put_user(0, &frame->uc.tuc_link);
 317     target_save_altstack(&frame->uc.tuc_stack, env);
 318     err |= target_rt_setup_ucontext(&frame->uc, env);
 319
 320     if (err)
 321         goto give_sigsegv;
 322
 323     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
 324         __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
 325     }
 326
 327     /* Set up to return from userspace.  */
 328
 329     retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode);
 330     __put_user(retcode_addr, &frame->pretcode);
 331
 332     /* moveq #,d0; notb d0; trap #0 */
 333
 334     __put_user(0x70004600 + ((TARGET_NR_rt_sigreturn ^ 0xff) << 16),
 335                (uint32_t *)(frame->retcode + 0));
 336     __put_user(0x4e40, (uint16_t *)(frame->retcode + 4));
 337
 338     if (err)
 339         goto give_sigsegv;
 340
 341     /* Set up to return from userspace */
 342
 343     env->aregs[7] = frame_addr;
 344     env->pc = ka->_sa_handler;
 345
 346     unlock_user_struct(frame, frame_addr, 1);
 347     return;
 348
 349 give_sigsegv:
 350     unlock_user_struct(frame, frame_addr, 1);
 351     force_sigsegv(sig);
 352 }
 353
 354 long do_sigreturn(CPUM68KState *env)
 355 {
 356     struct target_sigframe *frame;
 357     abi_ulong frame_addr = env->aregs[7] - 4;
 358     target_sigset_t target_set;
 359     sigset_t set;
 360     int i;
 361
 362     trace_user_do_sigreturn(env, frame_addr);
 363     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
 364         goto badframe;
 365
 366     /* set blocked signals */
 367
 368     __get_user(target_set.sig[0], &frame->sc.sc_mask);
 369
 370     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
 371         __get_user(target_set.sig[i], &frame->extramask[i - 1]);
 372     }
 373
 374     target_to_host_sigset_internal(&set, &target_set);
 375     set_sigmask(&set);
 376
 377     /* restore registers */
 378
 379     restore_sigcontext(env, &frame->sc);
 380
 381     unlock_user_struct(frame, frame_addr, 0);
 382     return -TARGET_QEMU_ESIGRETURN;
 383
 384 badframe:
 385     force_sig(TARGET_SIGSEGV);
 386     return -TARGET_QEMU_ESIGRETURN;
 387 }
 388
 389 long do_rt_sigreturn(CPUM68KState *env)
 390 {
 391     struct target_rt_sigframe *frame;
 392     abi_ulong frame_addr = env->aregs[7] - 4;
 393     sigset_t set;
 394
 395     trace_user_do_rt_sigreturn(env, frame_addr);
 396     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
 397         goto badframe;
 398
 399     target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
 400     set_sigmask(&set);
 401
 402     /* restore registers */
 403
 404     if (target_rt_restore_ucontext(env, &frame->uc))
 405         goto badframe;
 406
 407     if (do_sigaltstack(frame_addr +
 408                        offsetof(struct target_rt_sigframe, uc.tuc_stack),
 409                        0, get_sp_from_cpustate(env)) == -EFAULT)
 410         goto badframe;
 411
 412     unlock_user_struct(frame, frame_addr, 0);
 413     return -TARGET_QEMU_ESIGRETURN;
 414
 415 badframe:
 416     unlock_user_struct(frame, frame_addr, 0);
 417     force_sig(TARGET_SIGSEGV);
 418     return -TARGET_QEMU_ESIGRETURN;
 419 }