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 "signal-common.h" 22 #include "linux-user/trace.h" 23 24 #define __NUM_GPRS 16 25 #define __NUM_FPRS 16 26 #define __NUM_ACRS 16 27 28 #define __SIGNAL_FRAMESIZE 160 /* FIXME: 31-bit mode -> 96 */ 29 30 #define _SIGCONTEXT_NSIG 64 31 #define _SIGCONTEXT_NSIG_BPW 64 /* FIXME: 31-bit mode -> 32 */ 32 #define _SIGCONTEXT_NSIG_WORDS (_SIGCONTEXT_NSIG / _SIGCONTEXT_NSIG_BPW) 33 #define _SIGMASK_COPY_SIZE (sizeof(unsigned long)*_SIGCONTEXT_NSIG_WORDS) 34 #define S390_SYSCALL_OPCODE ((uint16_t)0x0a00) 35 36 typedef struct { 37 target_psw_t psw; 38 abi_ulong gprs[__NUM_GPRS]; 39 abi_uint acrs[__NUM_ACRS]; 40 } target_s390_regs_common; 41 42 typedef struct { 43 uint32_t fpc; 44 uint32_t pad; 45 uint64_t fprs[__NUM_FPRS]; 46 } target_s390_fp_regs; 47 48 typedef struct { 49 target_s390_regs_common regs; 50 target_s390_fp_regs fpregs; 51 } target_sigregs; 52 53 typedef struct { 54 abi_ulong oldmask[_SIGCONTEXT_NSIG_WORDS]; 55 abi_ulong sregs; 56 } target_sigcontext; 57 58 typedef struct { 59 uint8_t callee_used_stack[__SIGNAL_FRAMESIZE]; 60 target_sigcontext sc; 61 target_sigregs sregs; 62 int signo; 63 uint16_t retcode; 64 } sigframe; 65 66 struct target_ucontext { 67 abi_ulong tuc_flags; 68 abi_ulong tuc_link; 69 target_stack_t tuc_stack; 70 target_sigregs tuc_mcontext; 71 target_sigset_t tuc_sigmask; /* mask last for extensibility */ 72 }; 73 74 typedef struct { 75 uint8_t callee_used_stack[__SIGNAL_FRAMESIZE]; 76 uint16_t retcode; 77 struct target_siginfo info; 78 struct target_ucontext uc; 79 } rt_sigframe; 80 81 static inline abi_ulong 82 get_sigframe(struct target_sigaction *ka, CPUS390XState *env, size_t frame_size) 83 { 84 abi_ulong sp; 85 86 /* Default to using normal stack */ 87 sp = get_sp_from_cpustate(env); 88 89 /* This is the X/Open sanctioned signal stack switching. */ 90 if (ka->sa_flags & TARGET_SA_ONSTACK) { 91 sp = target_sigsp(sp, ka); 92 } 93 94 /* This is the legacy signal stack switching. */ 95 else if (/* FIXME !user_mode(regs) */ 0 && 96 !(ka->sa_flags & TARGET_SA_RESTORER) && 97 ka->sa_restorer) { 98 sp = (abi_ulong) ka->sa_restorer; 99 } 100 101 return (sp - frame_size) & -8ul; 102 } 103 104 static void save_sigregs(CPUS390XState *env, target_sigregs *sregs) 105 { 106 int i; 107 108 /* 109 * Copy a 'clean' PSW mask to the user to avoid leaking 110 * information about whether PER is currently on. 111 */ 112 __put_user(env->psw.mask, &sregs->regs.psw.mask); 113 __put_user(env->psw.addr, &sregs->regs.psw.addr); 114 115 for (i = 0; i < 16; i++) { 116 __put_user(env->regs[i], &sregs->regs.gprs[i]); 117 } 118 for (i = 0; i < 16; i++) { 119 __put_user(env->aregs[i], &sregs->regs.acrs[i]); 120 } 121 122 /* 123 * We have to store the fp registers to current->thread.fp_regs 124 * to merge them with the emulated registers. 125 */ 126 for (i = 0; i < 16; i++) { 127 __put_user(*get_freg(env, i), &sregs->fpregs.fprs[i]); 128 } 129 } 130 131 void setup_frame(int sig, struct target_sigaction *ka, 132 target_sigset_t *set, CPUS390XState *env) 133 { 134 sigframe *frame; 135 abi_ulong frame_addr; 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 force_sigsegv(sig); 141 return; 142 } 143 144 __put_user(set->sig[0], &frame->sc.oldmask[0]); 145 146 save_sigregs(env, &frame->sregs); 147 148 __put_user(frame_addr + offsetof(sigframe, sregs), &frame->sc.sregs); 149 150 /* Set up to return from userspace. If provided, use a stub 151 already in userspace. */ 152 if (ka->sa_flags & TARGET_SA_RESTORER) { 153 env->regs[14] = ka->sa_restorer; 154 } else { 155 env->regs[14] = frame_addr + offsetof(sigframe, retcode); 156 __put_user(S390_SYSCALL_OPCODE | TARGET_NR_sigreturn, 157 &frame->retcode); 158 } 159 160 /* Set up backchain. */ 161 __put_user(env->regs[15], (abi_ulong *) frame); 162 163 /* Set up registers for signal handler */ 164 env->regs[15] = frame_addr; 165 /* Force default amode and default user address space control. */ 166 env->psw.mask = PSW_MASK_64 | PSW_MASK_32 | PSW_ASC_PRIMARY 167 | (env->psw.mask & ~PSW_MASK_ASC); 168 env->psw.addr = ka->_sa_handler; 169 170 env->regs[2] = sig; //map_signal(sig); 171 env->regs[3] = frame_addr += offsetof(typeof(*frame), sc); 172 173 /* We forgot to include these in the sigcontext. 174 To avoid breaking binary compatibility, they are passed as args. */ 175 env->regs[4] = 0; // FIXME: no clue... current->thread.trap_no; 176 env->regs[5] = 0; // FIXME: no clue... current->thread.prot_addr; 177 178 /* Place signal number on stack to allow backtrace from handler. */ 179 __put_user(env->regs[2], &frame->signo); 180 unlock_user_struct(frame, frame_addr, 1); 181 } 182 183 void setup_rt_frame(int sig, struct target_sigaction *ka, 184 target_siginfo_t *info, 185 target_sigset_t *set, CPUS390XState *env) 186 { 187 rt_sigframe *frame; 188 abi_ulong frame_addr; 189 190 frame_addr = get_sigframe(ka, env, sizeof *frame); 191 trace_user_setup_rt_frame(env, frame_addr); 192 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 193 force_sigsegv(sig); 194 return; 195 } 196 197 tswap_siginfo(&frame->info, info); 198 199 /* Create the ucontext. */ 200 __put_user(0, &frame->uc.tuc_flags); 201 __put_user((abi_ulong)0, (abi_ulong *)&frame->uc.tuc_link); 202 target_save_altstack(&frame->uc.tuc_stack, env); 203 save_sigregs(env, &frame->uc.tuc_mcontext); 204 tswap_sigset(&frame->uc.tuc_sigmask, set); 205 206 /* Set up to return from userspace. If provided, use a stub 207 already in userspace. */ 208 if (ka->sa_flags & TARGET_SA_RESTORER) { 209 env->regs[14] = ka->sa_restorer; 210 } else { 211 env->regs[14] = frame_addr + offsetof(typeof(*frame), retcode); 212 __put_user(S390_SYSCALL_OPCODE | TARGET_NR_rt_sigreturn, 213 &frame->retcode); 214 } 215 216 /* Set up backchain. */ 217 __put_user(env->regs[15], (abi_ulong *) frame); 218 219 /* Set up registers for signal handler */ 220 env->regs[15] = frame_addr; 221 /* Force default amode and default user address space control. */ 222 env->psw.mask = PSW_MASK_64 | PSW_MASK_32 | PSW_ASC_PRIMARY 223 | (env->psw.mask & ~PSW_MASK_ASC); 224 env->psw.addr = ka->_sa_handler; 225 226 env->regs[2] = sig; //map_signal(sig); 227 env->regs[3] = frame_addr + offsetof(typeof(*frame), info); 228 env->regs[4] = frame_addr + offsetof(typeof(*frame), uc); 229 } 230 231 static void restore_sigregs(CPUS390XState *env, target_sigregs *sc) 232 { 233 target_ulong prev_addr; 234 int i; 235 236 for (i = 0; i < 16; i++) { 237 __get_user(env->regs[i], &sc->regs.gprs[i]); 238 } 239 240 prev_addr = env->psw.addr; 241 __get_user(env->psw.mask, &sc->regs.psw.mask); 242 __get_user(env->psw.addr, &sc->regs.psw.addr); 243 trace_user_s390x_restore_sigregs(env, env->psw.addr, prev_addr); 244 245 for (i = 0; i < 16; i++) { 246 __get_user(env->aregs[i], &sc->regs.acrs[i]); 247 } 248 for (i = 0; i < 16; i++) { 249 __get_user(*get_freg(env, i), &sc->fpregs.fprs[i]); 250 } 251 } 252 253 long do_sigreturn(CPUS390XState *env) 254 { 255 sigframe *frame; 256 abi_ulong frame_addr = env->regs[15]; 257 target_sigset_t target_set; 258 sigset_t set; 259 260 trace_user_do_sigreturn(env, frame_addr); 261 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) { 262 force_sig(TARGET_SIGSEGV); 263 return -TARGET_QEMU_ESIGRETURN; 264 } 265 __get_user(target_set.sig[0], &frame->sc.oldmask[0]); 266 267 target_to_host_sigset_internal(&set, &target_set); 268 set_sigmask(&set); /* ~_BLOCKABLE? */ 269 270 restore_sigregs(env, &frame->sregs); 271 272 unlock_user_struct(frame, frame_addr, 0); 273 return -TARGET_QEMU_ESIGRETURN; 274 } 275 276 long do_rt_sigreturn(CPUS390XState *env) 277 { 278 rt_sigframe *frame; 279 abi_ulong frame_addr = env->regs[15]; 280 sigset_t set; 281 282 trace_user_do_rt_sigreturn(env, frame_addr); 283 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) { 284 force_sig(TARGET_SIGSEGV); 285 return -TARGET_QEMU_ESIGRETURN; 286 } 287 target_to_host_sigset(&set, &frame->uc.tuc_sigmask); 288 289 set_sigmask(&set); /* ~_BLOCKABLE? */ 290 291 restore_sigregs(env, &frame->uc.tuc_mcontext); 292 293 target_restore_altstack(&frame->uc.tuc_stack, env); 294 295 unlock_user_struct(frame, frame_addr, 0); 296 return -TARGET_QEMU_ESIGRETURN; 297 } 298