1 /* 2 * This file is subject to the terms and conditions of the GNU General Public 3 * License. See the file "COPYING" in the main directory of this archive 4 * for more details. 5 * 6 * Copyright (C) 1991, 1992 Linus Torvalds 7 * Copyright (C) 1994 - 2000, 2006 Ralf Baechle 8 * Copyright (C) 1999, 2000 Silicon Graphics, Inc. 9 */ 10 #include <linux/cache.h> 11 #include <linux/compat.h> 12 #include <linux/sched.h> 13 #include <linux/mm.h> 14 #include <linux/smp.h> 15 #include <linux/kernel.h> 16 #include <linux/signal.h> 17 #include <linux/syscalls.h> 18 #include <linux/errno.h> 19 #include <linux/wait.h> 20 #include <linux/ptrace.h> 21 #include <linux/suspend.h> 22 #include <linux/compiler.h> 23 #include <linux/uaccess.h> 24 25 #include <asm/abi.h> 26 #include <asm/asm.h> 27 #include <asm/compat-signal.h> 28 #include <linux/bitops.h> 29 #include <asm/cacheflush.h> 30 #include <asm/sim.h> 31 #include <asm/ucontext.h> 32 #include <asm/fpu.h> 33 #include <asm/war.h> 34 #include <asm/dsp.h> 35 36 #include "signal-common.h" 37 38 /* 39 * Including <asm/unistd.h> would give use the 64-bit syscall numbers ... 40 */ 41 #define __NR_O32_restart_syscall 4253 42 43 /* 32-bit compatibility types */ 44 45 typedef unsigned int __sighandler32_t; 46 typedef void (*vfptr_t)(void); 47 48 struct ucontext32 { 49 u32 uc_flags; 50 s32 uc_link; 51 compat_stack_t uc_stack; 52 struct sigcontext32 uc_mcontext; 53 compat_sigset_t uc_sigmask; /* mask last for extensibility */ 54 }; 55 56 struct sigframe32 { 57 u32 sf_ass[4]; /* argument save space for o32 */ 58 u32 sf_pad[2]; /* Was: signal trampoline */ 59 struct sigcontext32 sf_sc; 60 compat_sigset_t sf_mask; 61 }; 62 63 struct rt_sigframe32 { 64 u32 rs_ass[4]; /* argument save space for o32 */ 65 u32 rs_pad[2]; /* Was: signal trampoline */ 66 compat_siginfo_t rs_info; 67 struct ucontext32 rs_uc; 68 }; 69 70 static int setup_sigcontext32(struct pt_regs *regs, 71 struct sigcontext32 __user *sc) 72 { 73 int err = 0; 74 int i; 75 76 err |= __put_user(regs->cp0_epc, &sc->sc_pc); 77 78 err |= __put_user(0, &sc->sc_regs[0]); 79 for (i = 1; i < 32; i++) 80 err |= __put_user(regs->regs[i], &sc->sc_regs[i]); 81 82 err |= __put_user(regs->hi, &sc->sc_mdhi); 83 err |= __put_user(regs->lo, &sc->sc_mdlo); 84 if (cpu_has_dsp) { 85 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp); 86 err |= __put_user(mfhi1(), &sc->sc_hi1); 87 err |= __put_user(mflo1(), &sc->sc_lo1); 88 err |= __put_user(mfhi2(), &sc->sc_hi2); 89 err |= __put_user(mflo2(), &sc->sc_lo2); 90 err |= __put_user(mfhi3(), &sc->sc_hi3); 91 err |= __put_user(mflo3(), &sc->sc_lo3); 92 } 93 94 /* 95 * Save FPU state to signal context. Signal handler 96 * will "inherit" current FPU state. 97 */ 98 err |= protected_save_fp_context(sc); 99 100 return err; 101 } 102 103 static int restore_sigcontext32(struct pt_regs *regs, 104 struct sigcontext32 __user *sc) 105 { 106 int err = 0; 107 s32 treg; 108 int i; 109 110 /* Always make any pending restarted system calls return -EINTR */ 111 current->restart_block.fn = do_no_restart_syscall; 112 113 err |= __get_user(regs->cp0_epc, &sc->sc_pc); 114 err |= __get_user(regs->hi, &sc->sc_mdhi); 115 err |= __get_user(regs->lo, &sc->sc_mdlo); 116 if (cpu_has_dsp) { 117 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg); 118 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg); 119 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg); 120 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg); 121 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg); 122 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg); 123 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK); 124 } 125 126 for (i = 1; i < 32; i++) 127 err |= __get_user(regs->regs[i], &sc->sc_regs[i]); 128 129 return err ?: protected_restore_fp_context(sc); 130 } 131 132 /* 133 * Atomically swap in the new signal mask, and wait for a signal. 134 */ 135 136 asmlinkage int sys32_sigsuspend(compat_sigset_t __user *uset) 137 { 138 return compat_sys_rt_sigsuspend(uset, sizeof(compat_sigset_t)); 139 } 140 141 SYSCALL_DEFINE3(32_sigaction, long, sig, const struct compat_sigaction __user *, act, 142 struct compat_sigaction __user *, oact) 143 { 144 struct k_sigaction new_ka, old_ka; 145 int ret; 146 int err = 0; 147 148 if (act) { 149 old_sigset_t mask; 150 s32 handler; 151 152 if (!access_ok(VERIFY_READ, act, sizeof(*act))) 153 return -EFAULT; 154 err |= __get_user(handler, &act->sa_handler); 155 new_ka.sa.sa_handler = (void __user *)(s64)handler; 156 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags); 157 err |= __get_user(mask, &act->sa_mask.sig[0]); 158 if (err) 159 return -EFAULT; 160 161 siginitset(&new_ka.sa.sa_mask, mask); 162 } 163 164 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 165 166 if (!ret && oact) { 167 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact))) 168 return -EFAULT; 169 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags); 170 err |= __put_user((u32)(u64)old_ka.sa.sa_handler, 171 &oact->sa_handler); 172 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig); 173 err |= __put_user(0, &oact->sa_mask.sig[1]); 174 err |= __put_user(0, &oact->sa_mask.sig[2]); 175 err |= __put_user(0, &oact->sa_mask.sig[3]); 176 if (err) 177 return -EFAULT; 178 } 179 180 return ret; 181 } 182 183 int copy_siginfo_to_user32(compat_siginfo_t __user *to, const siginfo_t *from) 184 { 185 int err; 186 187 if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t))) 188 return -EFAULT; 189 190 /* If you change siginfo_t structure, please be sure 191 this code is fixed accordingly. 192 It should never copy any pad contained in the structure 193 to avoid security leaks, but must copy the generic 194 3 ints plus the relevant union member. 195 This routine must convert siginfo from 64bit to 32bit as well 196 at the same time. */ 197 err = __put_user(from->si_signo, &to->si_signo); 198 err |= __put_user(from->si_errno, &to->si_errno); 199 err |= __put_user((short)from->si_code, &to->si_code); 200 if (from->si_code < 0) 201 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE); 202 else { 203 switch (from->si_code >> 16) { 204 case __SI_TIMER >> 16: 205 err |= __put_user(from->si_tid, &to->si_tid); 206 err |= __put_user(from->si_overrun, &to->si_overrun); 207 err |= __put_user(from->si_int, &to->si_int); 208 break; 209 case __SI_CHLD >> 16: 210 err |= __put_user(from->si_utime, &to->si_utime); 211 err |= __put_user(from->si_stime, &to->si_stime); 212 err |= __put_user(from->si_status, &to->si_status); 213 default: 214 err |= __put_user(from->si_pid, &to->si_pid); 215 err |= __put_user(from->si_uid, &to->si_uid); 216 break; 217 case __SI_FAULT >> 16: 218 err |= __put_user((unsigned long)from->si_addr, &to->si_addr); 219 break; 220 case __SI_POLL >> 16: 221 err |= __put_user(from->si_band, &to->si_band); 222 err |= __put_user(from->si_fd, &to->si_fd); 223 break; 224 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */ 225 case __SI_MESGQ >> 16: 226 err |= __put_user(from->si_pid, &to->si_pid); 227 err |= __put_user(from->si_uid, &to->si_uid); 228 err |= __put_user(from->si_int, &to->si_int); 229 break; 230 case __SI_SYS >> 16: 231 err |= __copy_to_user(&to->si_call_addr, &from->si_call_addr, 232 sizeof(compat_uptr_t)); 233 err |= __put_user(from->si_syscall, &to->si_syscall); 234 err |= __put_user(from->si_arch, &to->si_arch); 235 break; 236 } 237 } 238 return err; 239 } 240 241 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from) 242 { 243 if (copy_from_user(to, from, 3*sizeof(int)) || 244 copy_from_user(to->_sifields._pad, 245 from->_sifields._pad, SI_PAD_SIZE32)) 246 return -EFAULT; 247 248 return 0; 249 } 250 251 asmlinkage void sys32_sigreturn(nabi_no_regargs struct pt_regs regs) 252 { 253 struct sigframe32 __user *frame; 254 sigset_t blocked; 255 int sig; 256 257 frame = (struct sigframe32 __user *) regs.regs[29]; 258 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 259 goto badframe; 260 if (__copy_conv_sigset_from_user(&blocked, &frame->sf_mask)) 261 goto badframe; 262 263 set_current_blocked(&blocked); 264 265 sig = restore_sigcontext32(®s, &frame->sf_sc); 266 if (sig < 0) 267 goto badframe; 268 else if (sig) 269 force_sig(sig, current); 270 271 /* 272 * Don't let your children do this ... 273 */ 274 __asm__ __volatile__( 275 "move\t$29, %0\n\t" 276 "j\tsyscall_exit" 277 :/* no outputs */ 278 :"r" (®s)); 279 /* Unreached */ 280 281 badframe: 282 force_sig(SIGSEGV, current); 283 } 284 285 asmlinkage void sys32_rt_sigreturn(nabi_no_regargs struct pt_regs regs) 286 { 287 struct rt_sigframe32 __user *frame; 288 sigset_t set; 289 int sig; 290 291 frame = (struct rt_sigframe32 __user *) regs.regs[29]; 292 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 293 goto badframe; 294 if (__copy_conv_sigset_from_user(&set, &frame->rs_uc.uc_sigmask)) 295 goto badframe; 296 297 set_current_blocked(&set); 298 299 sig = restore_sigcontext32(®s, &frame->rs_uc.uc_mcontext); 300 if (sig < 0) 301 goto badframe; 302 else if (sig) 303 force_sig(sig, current); 304 305 if (compat_restore_altstack(&frame->rs_uc.uc_stack)) 306 goto badframe; 307 308 /* 309 * Don't let your children do this ... 310 */ 311 __asm__ __volatile__( 312 "move\t$29, %0\n\t" 313 "j\tsyscall_exit" 314 :/* no outputs */ 315 :"r" (®s)); 316 /* Unreached */ 317 318 badframe: 319 force_sig(SIGSEGV, current); 320 } 321 322 static int setup_frame_32(void *sig_return, struct ksignal *ksig, 323 struct pt_regs *regs, sigset_t *set) 324 { 325 struct sigframe32 __user *frame; 326 int err = 0; 327 328 frame = get_sigframe(ksig, regs, sizeof(*frame)); 329 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame))) 330 return -EFAULT; 331 332 err |= setup_sigcontext32(regs, &frame->sf_sc); 333 err |= __copy_conv_sigset_to_user(&frame->sf_mask, set); 334 335 if (err) 336 return -EFAULT; 337 338 /* 339 * Arguments to signal handler: 340 * 341 * a0 = signal number 342 * a1 = 0 (should be cause) 343 * a2 = pointer to struct sigcontext 344 * 345 * $25 and c0_epc point to the signal handler, $29 points to the 346 * struct sigframe. 347 */ 348 regs->regs[ 4] = ksig->sig; 349 regs->regs[ 5] = 0; 350 regs->regs[ 6] = (unsigned long) &frame->sf_sc; 351 regs->regs[29] = (unsigned long) frame; 352 regs->regs[31] = (unsigned long) sig_return; 353 regs->cp0_epc = regs->regs[25] = (unsigned long) ksig->ka.sa.sa_handler; 354 355 DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n", 356 current->comm, current->pid, 357 frame, regs->cp0_epc, regs->regs[31]); 358 359 return 0; 360 } 361 362 static int setup_rt_frame_32(void *sig_return, struct ksignal *ksig, 363 struct pt_regs *regs, sigset_t *set) 364 { 365 struct rt_sigframe32 __user *frame; 366 int err = 0; 367 368 frame = get_sigframe(ksig, regs, sizeof(*frame)); 369 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame))) 370 return -EFAULT; 371 372 /* Convert (siginfo_t -> compat_siginfo_t) and copy to user. */ 373 err |= copy_siginfo_to_user32(&frame->rs_info, &ksig->info); 374 375 /* Create the ucontext. */ 376 err |= __put_user(0, &frame->rs_uc.uc_flags); 377 err |= __put_user(0, &frame->rs_uc.uc_link); 378 err |= __compat_save_altstack(&frame->rs_uc.uc_stack, regs->regs[29]); 379 err |= setup_sigcontext32(regs, &frame->rs_uc.uc_mcontext); 380 err |= __copy_conv_sigset_to_user(&frame->rs_uc.uc_sigmask, set); 381 382 if (err) 383 return -EFAULT; 384 385 /* 386 * Arguments to signal handler: 387 * 388 * a0 = signal number 389 * a1 = 0 (should be cause) 390 * a2 = pointer to ucontext 391 * 392 * $25 and c0_epc point to the signal handler, $29 points to 393 * the struct rt_sigframe32. 394 */ 395 regs->regs[ 4] = ksig->sig; 396 regs->regs[ 5] = (unsigned long) &frame->rs_info; 397 regs->regs[ 6] = (unsigned long) &frame->rs_uc; 398 regs->regs[29] = (unsigned long) frame; 399 regs->regs[31] = (unsigned long) sig_return; 400 regs->cp0_epc = regs->regs[25] = (unsigned long) ksig->ka.sa.sa_handler; 401 402 DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n", 403 current->comm, current->pid, 404 frame, regs->cp0_epc, regs->regs[31]); 405 406 return 0; 407 } 408 409 /* 410 * o32 compatibility on 64-bit kernels, without DSP ASE 411 */ 412 struct mips_abi mips_abi_32 = { 413 .setup_frame = setup_frame_32, 414 .setup_rt_frame = setup_rt_frame_32, 415 .restart = __NR_O32_restart_syscall, 416 417 .off_sc_fpregs = offsetof(struct sigcontext32, sc_fpregs), 418 .off_sc_fpc_csr = offsetof(struct sigcontext32, sc_fpc_csr), 419 .off_sc_used_math = offsetof(struct sigcontext32, sc_used_math), 420 421 .vdso = &vdso_image_o32, 422 }; 423