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