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 typedef struct target_sigcontext { 26 struct target_pt_regs regs; 27 abi_ulong oldmask; 28 } target_sigcontext; 29 30 typedef struct target_ucontext { 31 abi_ulong tuc_flags; 32 abi_ulong tuc_link; 33 target_stack_t tuc_stack; 34 target_sigcontext tuc_mcontext; 35 target_sigset_t tuc_sigmask; /* mask last for extensibility */ 36 } target_ucontext; 37 38 typedef struct target_rt_sigframe { 39 struct target_siginfo info; 40 target_ucontext uc; 41 } target_rt_sigframe; 42 43 static void restore_sigcontext(CPUOpenRISCState *env, target_sigcontext *sc) 44 { 45 int i; 46 abi_ulong v; 47 48 for (i = 0; i < 32; ++i) { 49 __get_user(v, &sc->regs.gpr[i]); 50 cpu_set_gpr(env, i, v); 51 } 52 __get_user(env->pc, &sc->regs.pc); 53 54 /* Make sure the supervisor flag is clear. */ 55 __get_user(v, &sc->regs.sr); 56 cpu_set_sr(env, v & ~SR_SM); 57 } 58 59 /* Set up a signal frame. */ 60 61 static void setup_sigcontext(target_sigcontext *sc, CPUOpenRISCState *env) 62 { 63 int i; 64 65 for (i = 0; i < 32; ++i) { 66 __put_user(cpu_get_gpr(env, i), &sc->regs.gpr[i]); 67 } 68 69 __put_user(env->pc, &sc->regs.pc); 70 __put_user(cpu_get_sr(env), &sc->regs.sr); 71 } 72 73 static inline abi_ulong get_sigframe(struct target_sigaction *ka, 74 CPUOpenRISCState *env, 75 size_t frame_size) 76 { 77 target_ulong sp = get_sp_from_cpustate(env); 78 79 /* Honor redzone now. If we swap to signal stack, no need to waste 80 * the 128 bytes by subtracting afterward. 81 */ 82 sp -= 128; 83 84 sp = target_sigsp(sp, ka); 85 sp -= frame_size; 86 sp = QEMU_ALIGN_DOWN(sp, 4); 87 88 return sp; 89 } 90 91 void setup_rt_frame(int sig, struct target_sigaction *ka, 92 target_siginfo_t *info, 93 target_sigset_t *set, CPUOpenRISCState *env) 94 { 95 abi_ulong frame_addr; 96 target_rt_sigframe *frame; 97 int i; 98 99 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 100 trace_user_setup_rt_frame(env, frame_addr); 101 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 102 goto give_sigsegv; 103 } 104 105 if (ka->sa_flags & SA_SIGINFO) { 106 tswap_siginfo(&frame->info, info); 107 } 108 109 __put_user(0, &frame->uc.tuc_flags); 110 __put_user(0, &frame->uc.tuc_link); 111 112 target_save_altstack(&frame->uc.tuc_stack, env); 113 setup_sigcontext(&frame->uc.tuc_mcontext, env); 114 for (i = 0; i < TARGET_NSIG_WORDS; ++i) { 115 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]); 116 } 117 118 /* Set up registers for signal handler */ 119 cpu_set_gpr(env, 9, default_rt_sigreturn); 120 cpu_set_gpr(env, 3, sig); 121 cpu_set_gpr(env, 4, frame_addr + offsetof(target_rt_sigframe, info)); 122 cpu_set_gpr(env, 5, frame_addr + offsetof(target_rt_sigframe, uc)); 123 cpu_set_gpr(env, 1, frame_addr); 124 125 /* For debugging convenience, set ppc to the insn that faulted. */ 126 env->ppc = env->pc; 127 /* When setting the PC for the signal handler, exit delay slot. */ 128 env->pc = ka->_sa_handler; 129 env->dflag = 0; 130 return; 131 132 give_sigsegv: 133 unlock_user_struct(frame, frame_addr, 1); 134 force_sigsegv(sig); 135 } 136 137 long do_rt_sigreturn(CPUOpenRISCState *env) 138 { 139 abi_ulong frame_addr = get_sp_from_cpustate(env); 140 target_rt_sigframe *frame; 141 sigset_t set; 142 143 trace_user_do_rt_sigreturn(env, 0); 144 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) { 145 goto badframe; 146 } 147 if (frame_addr & 3) { 148 goto badframe; 149 } 150 151 target_to_host_sigset(&set, &frame->uc.tuc_sigmask); 152 set_sigmask(&set); 153 154 restore_sigcontext(env, &frame->uc.tuc_mcontext); 155 target_restore_altstack(&frame->uc.tuc_stack, env); 156 157 unlock_user_struct(frame, frame_addr, 0); 158 return cpu_get_gpr(env, 11); 159 160 badframe: 161 unlock_user_struct(frame, frame_addr, 0); 162 force_sig(TARGET_SIGSEGV); 163 return 0; 164 } 165 166 void setup_sigtramp(abi_ulong sigtramp_page) 167 { 168 uint32_t *tramp = lock_user(VERIFY_WRITE, sigtramp_page, 8, 0); 169 assert(tramp != NULL); 170 171 /* This is l.ori r11,r0,__NR_sigreturn; l.sys 1 */ 172 __put_user(0xa9600000 | TARGET_NR_rt_sigreturn, tramp + 0); 173 __put_user(0x20000001, tramp + 1); 174 175 default_rt_sigreturn = sigtramp_page; 176 unlock_user(tramp, sigtramp_page, 8); 177 } 178