signal.c (12799B)
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 #define __NUM_GPRS 16 26 #define __NUM_FPRS 16 27 #define __NUM_ACRS 16 28 29 #define __SIGNAL_FRAMESIZE 160 /* FIXME: 31-bit mode -> 96 */ 30 31 #define _SIGCONTEXT_NSIG 64 32 #define _SIGCONTEXT_NSIG_BPW 64 /* FIXME: 31-bit mode -> 32 */ 33 #define _SIGCONTEXT_NSIG_WORDS (_SIGCONTEXT_NSIG / _SIGCONTEXT_NSIG_BPW) 34 #define _SIGMASK_COPY_SIZE (sizeof(unsigned long)*_SIGCONTEXT_NSIG_WORDS) 35 #define S390_SYSCALL_OPCODE ((uint16_t)0x0a00) 36 37 typedef struct { 38 target_psw_t psw; 39 abi_ulong gprs[__NUM_GPRS]; 40 abi_uint acrs[__NUM_ACRS]; 41 } target_s390_regs_common; 42 43 typedef struct { 44 uint32_t fpc; 45 uint32_t pad; 46 uint64_t fprs[__NUM_FPRS]; 47 } target_s390_fp_regs; 48 49 typedef struct { 50 target_s390_regs_common regs; 51 target_s390_fp_regs fpregs; 52 } target_sigregs; 53 54 typedef struct { 55 uint64_t vxrs_low[16]; 56 uint64_t vxrs_high[16][2]; 57 uint8_t reserved[128]; 58 } target_sigregs_ext; 59 60 typedef struct { 61 abi_ulong oldmask[_SIGCONTEXT_NSIG_WORDS]; 62 abi_ulong sregs; 63 } target_sigcontext; 64 65 typedef struct { 66 uint8_t callee_used_stack[__SIGNAL_FRAMESIZE]; 67 target_sigcontext sc; 68 target_sigregs sregs; 69 int signo; 70 target_sigregs_ext sregs_ext; 71 } sigframe; 72 73 #define TARGET_UC_VXRS 2 74 75 struct target_ucontext { 76 abi_ulong tuc_flags; 77 abi_ulong tuc_link; 78 target_stack_t tuc_stack; 79 target_sigregs tuc_mcontext; 80 target_sigset_t tuc_sigmask; 81 uint8_t reserved[128 - sizeof(target_sigset_t)]; 82 target_sigregs_ext tuc_mcontext_ext; 83 }; 84 85 typedef struct { 86 uint8_t callee_used_stack[__SIGNAL_FRAMESIZE]; 87 /* 88 * This field is no longer initialized by the kernel, but it's still a part 89 * of the ABI. 90 */ 91 uint16_t svc_insn; 92 struct target_siginfo info; 93 struct target_ucontext uc; 94 } rt_sigframe; 95 96 static inline abi_ulong 97 get_sigframe(struct target_sigaction *ka, CPUS390XState *env, size_t frame_size) 98 { 99 abi_ulong sp; 100 101 /* Default to using normal stack */ 102 sp = get_sp_from_cpustate(env); 103 104 /* This is the X/Open sanctioned signal stack switching. */ 105 if (ka->sa_flags & TARGET_SA_ONSTACK) { 106 sp = target_sigsp(sp, ka); 107 } 108 109 /* This is the legacy signal stack switching. */ 110 else if (/* FIXME !user_mode(regs) */ 0 && 111 !(ka->sa_flags & TARGET_SA_RESTORER) && 112 ka->sa_restorer) { 113 sp = (abi_ulong) ka->sa_restorer; 114 } 115 116 return (sp - frame_size) & -8ul; 117 } 118 119 #define PSW_USER_BITS (PSW_MASK_DAT | PSW_MASK_IO | PSW_MASK_EXT | \ 120 PSW_MASK_MCHECK | PSW_MASK_PSTATE | PSW_ASC_PRIMARY) 121 #define PSW_MASK_USER (PSW_MASK_ASC | PSW_MASK_CC | PSW_MASK_PM | \ 122 PSW_MASK_64 | PSW_MASK_32) 123 124 static void save_sigregs(CPUS390XState *env, target_sigregs *sregs) 125 { 126 uint64_t psw_mask = s390_cpu_get_psw_mask(env); 127 int i; 128 129 /* 130 * Copy a 'clean' PSW mask to the user to avoid leaking 131 * information about whether PER is currently on. 132 * TODO: qemu does not support PSW_MASK_RI; it will never be set. 133 */ 134 psw_mask = PSW_USER_BITS | (psw_mask & PSW_MASK_USER); 135 __put_user(psw_mask, &sregs->regs.psw.mask); 136 __put_user(env->psw.addr, &sregs->regs.psw.addr); 137 138 for (i = 0; i < 16; i++) { 139 __put_user(env->regs[i], &sregs->regs.gprs[i]); 140 } 141 for (i = 0; i < 16; i++) { 142 __put_user(env->aregs[i], &sregs->regs.acrs[i]); 143 } 144 145 /* 146 * We have to store the fp registers to current->thread.fp_regs 147 * to merge them with the emulated registers. 148 */ 149 __put_user(env->fpc, &sregs->fpregs.fpc); 150 for (i = 0; i < 16; i++) { 151 __put_user(*get_freg(env, i), &sregs->fpregs.fprs[i]); 152 } 153 } 154 155 static void save_sigregs_ext(CPUS390XState *env, target_sigregs_ext *ext) 156 { 157 int i; 158 159 /* 160 * if (MACHINE_HAS_VX) ... 161 * That said, we always allocate the stack storage and the 162 * space is always available in env. 163 */ 164 for (i = 0; i < 16; ++i) { 165 __put_user(env->vregs[i][1], &ext->vxrs_low[i]); 166 } 167 for (i = 0; i < 16; ++i) { 168 __put_user(env->vregs[i + 16][0], &ext->vxrs_high[i][0]); 169 __put_user(env->vregs[i + 16][1], &ext->vxrs_high[i][1]); 170 } 171 } 172 173 void setup_frame(int sig, struct target_sigaction *ka, 174 target_sigset_t *set, CPUS390XState *env) 175 { 176 sigframe *frame; 177 abi_ulong frame_addr; 178 abi_ulong restorer; 179 180 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 181 trace_user_setup_frame(env, frame_addr); 182 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 183 force_sigsegv(sig); 184 return; 185 } 186 187 /* Set up backchain. */ 188 __put_user(env->regs[15], (abi_ulong *) frame); 189 190 /* Create struct sigcontext on the signal stack. */ 191 /* Make sure that we're initializing all of oldmask. */ 192 QEMU_BUILD_BUG_ON(ARRAY_SIZE(frame->sc.oldmask) != 1); 193 __put_user(set->sig[0], &frame->sc.oldmask[0]); 194 __put_user(frame_addr + offsetof(sigframe, sregs), &frame->sc.sregs); 195 196 /* Create _sigregs on the signal stack */ 197 save_sigregs(env, &frame->sregs); 198 199 /* 200 * ??? The kernel uses regs->gprs[2] here, which is not yet the signo. 201 * Moreover the comment talks about allowing backtrace, which is really 202 * done by the r15 copy above. 203 */ 204 __put_user(sig, &frame->signo); 205 206 /* Create sigregs_ext on the signal stack. */ 207 save_sigregs_ext(env, &frame->sregs_ext); 208 209 /* 210 * Set up to return from userspace. 211 * If provided, use a stub already in userspace. 212 */ 213 if (ka->sa_flags & TARGET_SA_RESTORER) { 214 restorer = ka->sa_restorer; 215 } else { 216 restorer = default_sigreturn; 217 } 218 219 /* Set up registers for signal handler */ 220 env->regs[14] = restorer; 221 env->regs[15] = frame_addr; 222 /* Force default amode and default user address space control. */ 223 env->psw.mask = PSW_MASK_64 | PSW_MASK_32 | PSW_ASC_PRIMARY 224 | (env->psw.mask & ~PSW_MASK_ASC); 225 env->psw.addr = ka->_sa_handler; 226 227 env->regs[2] = sig; 228 env->regs[3] = frame_addr + offsetof(typeof(*frame), sc); 229 230 /* 231 * We forgot to include these in the sigcontext. 232 * To avoid breaking binary compatibility, they are passed as args. 233 */ 234 env->regs[4] = 0; /* FIXME: regs->int_code & 127 */ 235 env->regs[5] = 0; /* FIXME: regs->int_parm_long */ 236 env->regs[6] = 0; /* FIXME: current->thread.last_break */ 237 238 unlock_user_struct(frame, frame_addr, 1); 239 } 240 241 void setup_rt_frame(int sig, struct target_sigaction *ka, 242 target_siginfo_t *info, 243 target_sigset_t *set, CPUS390XState *env) 244 { 245 rt_sigframe *frame; 246 abi_ulong frame_addr; 247 abi_ulong restorer; 248 abi_ulong uc_flags; 249 250 frame_addr = get_sigframe(ka, env, sizeof *frame); 251 trace_user_setup_rt_frame(env, frame_addr); 252 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 253 force_sigsegv(sig); 254 return; 255 } 256 257 /* Set up backchain. */ 258 __put_user(env->regs[15], (abi_ulong *) frame); 259 260 /* 261 * Set up to return from userspace. 262 * If provided, use a stub already in userspace. 263 */ 264 if (ka->sa_flags & TARGET_SA_RESTORER) { 265 restorer = ka->sa_restorer; 266 } else { 267 restorer = default_rt_sigreturn; 268 } 269 270 /* Create siginfo on the signal stack. */ 271 tswap_siginfo(&frame->info, info); 272 273 /* Create ucontext on the signal stack. */ 274 uc_flags = 0; 275 if (s390_has_feat(S390_FEAT_VECTOR)) { 276 uc_flags |= TARGET_UC_VXRS; 277 } 278 __put_user(uc_flags, &frame->uc.tuc_flags); 279 __put_user(0, &frame->uc.tuc_link); 280 target_save_altstack(&frame->uc.tuc_stack, env); 281 save_sigregs(env, &frame->uc.tuc_mcontext); 282 save_sigregs_ext(env, &frame->uc.tuc_mcontext_ext); 283 tswap_sigset(&frame->uc.tuc_sigmask, set); 284 285 /* Set up registers for signal handler */ 286 env->regs[14] = restorer; 287 env->regs[15] = frame_addr; 288 /* Force default amode and default user address space control. */ 289 env->psw.mask = PSW_MASK_64 | PSW_MASK_32 | PSW_ASC_PRIMARY 290 | (env->psw.mask & ~PSW_MASK_ASC); 291 env->psw.addr = ka->_sa_handler; 292 293 env->regs[2] = sig; 294 env->regs[3] = frame_addr + offsetof(typeof(*frame), info); 295 env->regs[4] = frame_addr + offsetof(typeof(*frame), uc); 296 env->regs[5] = 0; /* FIXME: current->thread.last_break */ 297 } 298 299 static void restore_sigregs(CPUS390XState *env, target_sigregs *sc) 300 { 301 uint64_t prev_addr, prev_mask, mask, addr; 302 int i; 303 304 for (i = 0; i < 16; i++) { 305 __get_user(env->regs[i], &sc->regs.gprs[i]); 306 } 307 308 prev_addr = env->psw.addr; 309 __get_user(mask, &sc->regs.psw.mask); 310 __get_user(addr, &sc->regs.psw.addr); 311 trace_user_s390x_restore_sigregs(env, addr, prev_addr); 312 313 /* 314 * Use current psw.mask to preserve PER bit. 315 * TODO: 316 * if (!is_ri_task(current) && (user_sregs.regs.psw.mask & PSW_MASK_RI)) 317 * return -EINVAL; 318 * Simply do not allow it to be set in mask. 319 */ 320 prev_mask = s390_cpu_get_psw_mask(env); 321 mask = (prev_mask & ~PSW_MASK_USER) | (mask & PSW_MASK_USER); 322 /* Check for invalid user address space control. */ 323 if ((mask & PSW_MASK_ASC) == PSW_ASC_HOME) { 324 mask = (mask & ~PSW_MASK_ASC) | PSW_ASC_PRIMARY; 325 } 326 /* Check for invalid amode. */ 327 if (mask & PSW_MASK_64) { 328 mask |= PSW_MASK_32; 329 } 330 s390_cpu_set_psw(env, mask, addr); 331 332 for (i = 0; i < 16; i++) { 333 __get_user(env->aregs[i], &sc->regs.acrs[i]); 334 } 335 __get_user(env->fpc, &sc->fpregs.fpc); 336 for (i = 0; i < 16; i++) { 337 __get_user(*get_freg(env, i), &sc->fpregs.fprs[i]); 338 } 339 } 340 341 static void restore_sigregs_ext(CPUS390XState *env, target_sigregs_ext *ext) 342 { 343 int i; 344 345 /* 346 * if (MACHINE_HAS_VX) ... 347 * That said, we always allocate the stack storage and the 348 * space is always available in env. 349 */ 350 for (i = 0; i < 16; ++i) { 351 __get_user(env->vregs[i][1], &ext->vxrs_low[i]); 352 } 353 for (i = 0; i < 16; ++i) { 354 __get_user(env->vregs[i + 16][0], &ext->vxrs_high[i][0]); 355 __get_user(env->vregs[i + 16][1], &ext->vxrs_high[i][1]); 356 } 357 } 358 359 long do_sigreturn(CPUS390XState *env) 360 { 361 sigframe *frame; 362 abi_ulong frame_addr = env->regs[15]; 363 target_sigset_t target_set; 364 sigset_t set; 365 366 trace_user_do_sigreturn(env, frame_addr); 367 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) { 368 force_sig(TARGET_SIGSEGV); 369 return -QEMU_ESIGRETURN; 370 } 371 372 /* Make sure that we're initializing all of target_set. */ 373 QEMU_BUILD_BUG_ON(ARRAY_SIZE(target_set.sig) != 1); 374 __get_user(target_set.sig[0], &frame->sc.oldmask[0]); 375 376 target_to_host_sigset_internal(&set, &target_set); 377 set_sigmask(&set); /* ~_BLOCKABLE? */ 378 379 restore_sigregs(env, &frame->sregs); 380 restore_sigregs_ext(env, &frame->sregs_ext); 381 382 unlock_user_struct(frame, frame_addr, 0); 383 return -QEMU_ESIGRETURN; 384 } 385 386 long do_rt_sigreturn(CPUS390XState *env) 387 { 388 rt_sigframe *frame; 389 abi_ulong frame_addr = env->regs[15]; 390 sigset_t set; 391 392 trace_user_do_rt_sigreturn(env, frame_addr); 393 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) { 394 force_sig(TARGET_SIGSEGV); 395 return -QEMU_ESIGRETURN; 396 } 397 target_to_host_sigset(&set, &frame->uc.tuc_sigmask); 398 399 set_sigmask(&set); /* ~_BLOCKABLE? */ 400 401 restore_sigregs(env, &frame->uc.tuc_mcontext); 402 restore_sigregs_ext(env, &frame->uc.tuc_mcontext_ext); 403 404 target_restore_altstack(&frame->uc.tuc_stack, env); 405 406 unlock_user_struct(frame, frame_addr, 0); 407 return -QEMU_ESIGRETURN; 408 } 409 410 void setup_sigtramp(abi_ulong sigtramp_page) 411 { 412 uint16_t *tramp = lock_user(VERIFY_WRITE, sigtramp_page, 2 + 2, 0); 413 assert(tramp != NULL); 414 415 default_sigreturn = sigtramp_page; 416 __put_user(S390_SYSCALL_OPCODE | TARGET_NR_sigreturn, &tramp[0]); 417 418 default_rt_sigreturn = sigtramp_page + 2; 419 __put_user(S390_SYSCALL_OPCODE | TARGET_NR_rt_sigreturn, &tramp[1]); 420 421 unlock_user(tramp, sigtramp_page, 2 + 2); 422 }