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 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 } 411