signal.c (6837B)
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 MCONTEXT_VERSION 2 26 27 struct target_sigcontext { 28 int version; 29 unsigned long gregs[32]; 30 }; 31 32 struct target_ucontext { 33 abi_ulong tuc_flags; 34 abi_ulong tuc_link; 35 target_stack_t tuc_stack; 36 struct target_sigcontext tuc_mcontext; 37 target_sigset_t tuc_sigmask; /* mask last for extensibility */ 38 }; 39 40 struct target_rt_sigframe { 41 struct target_siginfo info; 42 struct target_ucontext uc; 43 }; 44 45 static void rt_setup_ucontext(struct target_ucontext *uc, CPUNios2State *env) 46 { 47 unsigned long *gregs = uc->tuc_mcontext.gregs; 48 49 __put_user(MCONTEXT_VERSION, &uc->tuc_mcontext.version); 50 __put_user(env->regs[1], &gregs[0]); 51 __put_user(env->regs[2], &gregs[1]); 52 __put_user(env->regs[3], &gregs[2]); 53 __put_user(env->regs[4], &gregs[3]); 54 __put_user(env->regs[5], &gregs[4]); 55 __put_user(env->regs[6], &gregs[5]); 56 __put_user(env->regs[7], &gregs[6]); 57 __put_user(env->regs[8], &gregs[7]); 58 __put_user(env->regs[9], &gregs[8]); 59 __put_user(env->regs[10], &gregs[9]); 60 __put_user(env->regs[11], &gregs[10]); 61 __put_user(env->regs[12], &gregs[11]); 62 __put_user(env->regs[13], &gregs[12]); 63 __put_user(env->regs[14], &gregs[13]); 64 __put_user(env->regs[15], &gregs[14]); 65 __put_user(env->regs[16], &gregs[15]); 66 __put_user(env->regs[17], &gregs[16]); 67 __put_user(env->regs[18], &gregs[17]); 68 __put_user(env->regs[19], &gregs[18]); 69 __put_user(env->regs[20], &gregs[19]); 70 __put_user(env->regs[21], &gregs[20]); 71 __put_user(env->regs[22], &gregs[21]); 72 __put_user(env->regs[23], &gregs[22]); 73 __put_user(env->regs[R_RA], &gregs[23]); 74 __put_user(env->regs[R_FP], &gregs[24]); 75 __put_user(env->regs[R_GP], &gregs[25]); 76 __put_user(env->pc, &gregs[27]); 77 __put_user(env->regs[R_SP], &gregs[28]); 78 } 79 80 static int rt_restore_ucontext(CPUNios2State *env, struct target_ucontext *uc) 81 { 82 int temp; 83 unsigned long *gregs = uc->tuc_mcontext.gregs; 84 85 /* Always make any pending restarted system calls return -EINTR */ 86 /* current->restart_block.fn = do_no_restart_syscall; */ 87 88 __get_user(temp, &uc->tuc_mcontext.version); 89 if (temp != MCONTEXT_VERSION) { 90 return 1; 91 } 92 93 /* restore passed registers */ 94 __get_user(env->regs[1], &gregs[0]); 95 __get_user(env->regs[2], &gregs[1]); 96 __get_user(env->regs[3], &gregs[2]); 97 __get_user(env->regs[4], &gregs[3]); 98 __get_user(env->regs[5], &gregs[4]); 99 __get_user(env->regs[6], &gregs[5]); 100 __get_user(env->regs[7], &gregs[6]); 101 __get_user(env->regs[8], &gregs[7]); 102 __get_user(env->regs[9], &gregs[8]); 103 __get_user(env->regs[10], &gregs[9]); 104 __get_user(env->regs[11], &gregs[10]); 105 __get_user(env->regs[12], &gregs[11]); 106 __get_user(env->regs[13], &gregs[12]); 107 __get_user(env->regs[14], &gregs[13]); 108 __get_user(env->regs[15], &gregs[14]); 109 __get_user(env->regs[16], &gregs[15]); 110 __get_user(env->regs[17], &gregs[16]); 111 __get_user(env->regs[18], &gregs[17]); 112 __get_user(env->regs[19], &gregs[18]); 113 __get_user(env->regs[20], &gregs[19]); 114 __get_user(env->regs[21], &gregs[20]); 115 __get_user(env->regs[22], &gregs[21]); 116 __get_user(env->regs[23], &gregs[22]); 117 /* gregs[23] is handled below */ 118 /* Verify, should this be settable */ 119 __get_user(env->regs[R_FP], &gregs[24]); 120 /* Verify, should this be settable */ 121 __get_user(env->regs[R_GP], &gregs[25]); 122 /* Not really necessary no user settable bits */ 123 __get_user(temp, &gregs[26]); 124 __get_user(env->pc, &gregs[27]); 125 126 __get_user(env->regs[R_RA], &gregs[23]); 127 __get_user(env->regs[R_SP], &gregs[28]); 128 129 target_restore_altstack(&uc->tuc_stack, env); 130 return 0; 131 } 132 133 static abi_ptr get_sigframe(struct target_sigaction *ka, CPUNios2State *env, 134 size_t frame_size) 135 { 136 unsigned long usp; 137 138 /* This is the X/Open sanctioned signal stack switching. */ 139 usp = target_sigsp(get_sp_from_cpustate(env), ka); 140 141 /* Verify, is it 32 or 64 bit aligned */ 142 return (usp - frame_size) & -8; 143 } 144 145 void setup_rt_frame(int sig, struct target_sigaction *ka, 146 target_siginfo_t *info, 147 target_sigset_t *set, 148 CPUNios2State *env) 149 { 150 struct target_rt_sigframe *frame; 151 abi_ptr frame_addr; 152 int i; 153 154 frame_addr = get_sigframe(ka, env, sizeof(*frame)); 155 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { 156 force_sigsegv(sig); 157 return; 158 } 159 160 tswap_siginfo(&frame->info, info); 161 162 /* Create the ucontext. */ 163 __put_user(0, &frame->uc.tuc_flags); 164 __put_user(0, &frame->uc.tuc_link); 165 target_save_altstack(&frame->uc.tuc_stack, env); 166 rt_setup_ucontext(&frame->uc, env); 167 for (i = 0; i < TARGET_NSIG_WORDS; i++) { 168 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]); 169 } 170 171 /* Set up to return from userspace; jump to fixed address sigreturn 172 trampoline on kuser page. */ 173 env->regs[R_RA] = (unsigned long) (0x1044); 174 175 /* Set up registers for signal handler */ 176 env->regs[R_SP] = frame_addr; 177 env->regs[4] = sig; 178 env->regs[5] = frame_addr + offsetof(struct target_rt_sigframe, info); 179 env->regs[6] = frame_addr + offsetof(struct target_rt_sigframe, uc); 180 env->pc = ka->_sa_handler; 181 182 unlock_user_struct(frame, frame_addr, 1); 183 } 184 185 long do_rt_sigreturn(CPUNios2State *env) 186 { 187 /* Verify, can we follow the stack back */ 188 abi_ulong frame_addr = env->regs[R_SP]; 189 struct target_rt_sigframe *frame; 190 sigset_t set; 191 192 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) { 193 goto badframe; 194 } 195 196 target_to_host_sigset(&set, &frame->uc.tuc_sigmask); 197 set_sigmask(&set); 198 199 if (rt_restore_ucontext(env, &frame->uc)) { 200 goto badframe; 201 } 202 203 unlock_user_struct(frame, frame_addr, 0); 204 return -QEMU_ESIGRETURN; 205 206 badframe: 207 unlock_user_struct(frame, frame_addr, 0); 208 force_sig(TARGET_SIGSEGV); 209 return -QEMU_ESIGRETURN; 210 }