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 Ralf Baechle 8 * Copyright (C) 1999, 2000 Silicon Graphics, Inc. 9 */ 10 #include <linux/config.h> 11 #include <linux/cache.h> 12 #include <linux/sched.h> 13 #include <linux/mm.h> 14 #include <linux/personality.h> 15 #include <linux/smp.h> 16 #include <linux/smp_lock.h> 17 #include <linux/kernel.h> 18 #include <linux/signal.h> 19 #include <linux/errno.h> 20 #include <linux/wait.h> 21 #include <linux/ptrace.h> 22 #include <linux/unistd.h> 23 #include <linux/compiler.h> 24 25 #include <asm/abi.h> 26 #include <asm/asm.h> 27 #include <linux/bitops.h> 28 #include <asm/cacheflush.h> 29 #include <asm/fpu.h> 30 #include <asm/sim.h> 31 #include <asm/uaccess.h> 32 #include <asm/ucontext.h> 33 #include <asm/cpu-features.h> 34 #include <asm/war.h> 35 36 #include "signal-common.h" 37 38 #define DEBUG_SIG 0 39 40 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) 41 42 int do_signal(sigset_t *oldset, struct pt_regs *regs); 43 44 /* 45 * Atomically swap in the new signal mask, and wait for a signal. 46 */ 47 48 #ifdef CONFIG_TRAD_SIGNALS 49 save_static_function(sys_sigsuspend); 50 __attribute_used__ noinline static int 51 _sys_sigsuspend(nabi_no_regargs struct pt_regs regs) 52 { 53 sigset_t saveset, newset; 54 sigset_t __user *uset; 55 56 uset = (sigset_t __user *) regs.regs[4]; 57 if (copy_from_user(&newset, uset, sizeof(sigset_t))) 58 return -EFAULT; 59 sigdelsetmask(&newset, ~_BLOCKABLE); 60 61 spin_lock_irq(¤t->sighand->siglock); 62 saveset = current->blocked; 63 current->blocked = newset; 64 recalc_sigpending(); 65 spin_unlock_irq(¤t->sighand->siglock); 66 67 regs.regs[2] = EINTR; 68 regs.regs[7] = 1; 69 while (1) { 70 current->state = TASK_INTERRUPTIBLE; 71 schedule(); 72 if (do_signal(&saveset, ®s)) 73 return -EINTR; 74 } 75 } 76 #endif 77 78 save_static_function(sys_rt_sigsuspend); 79 __attribute_used__ noinline static int 80 _sys_rt_sigsuspend(nabi_no_regargs struct pt_regs regs) 81 { 82 sigset_t saveset, newset; 83 sigset_t __user *unewset; 84 size_t sigsetsize; 85 86 /* XXX Don't preclude handling different sized sigset_t's. */ 87 sigsetsize = regs.regs[5]; 88 if (sigsetsize != sizeof(sigset_t)) 89 return -EINVAL; 90 91 unewset = (sigset_t __user *) regs.regs[4]; 92 if (copy_from_user(&newset, unewset, sizeof(newset))) 93 return -EFAULT; 94 sigdelsetmask(&newset, ~_BLOCKABLE); 95 96 spin_lock_irq(¤t->sighand->siglock); 97 saveset = current->blocked; 98 current->blocked = newset; 99 recalc_sigpending(); 100 spin_unlock_irq(¤t->sighand->siglock); 101 102 regs.regs[2] = EINTR; 103 regs.regs[7] = 1; 104 while (1) { 105 current->state = TASK_INTERRUPTIBLE; 106 schedule(); 107 if (do_signal(&saveset, ®s)) 108 return -EINTR; 109 } 110 } 111 112 #ifdef CONFIG_TRAD_SIGNALS 113 asmlinkage int sys_sigaction(int sig, const struct sigaction *act, 114 struct sigaction *oact) 115 { 116 struct k_sigaction new_ka, old_ka; 117 int ret; 118 int err = 0; 119 120 if (act) { 121 old_sigset_t mask; 122 123 if (!access_ok(VERIFY_READ, act, sizeof(*act))) 124 return -EFAULT; 125 err |= __get_user(new_ka.sa.sa_handler, &act->sa_handler); 126 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags); 127 err |= __get_user(mask, &act->sa_mask.sig[0]); 128 if (err) 129 return -EFAULT; 130 131 siginitset(&new_ka.sa.sa_mask, mask); 132 } 133 134 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 135 136 if (!ret && oact) { 137 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact))) 138 return -EFAULT; 139 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags); 140 err |= __put_user(old_ka.sa.sa_handler, &oact->sa_handler); 141 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig); 142 err |= __put_user(0, &oact->sa_mask.sig[1]); 143 err |= __put_user(0, &oact->sa_mask.sig[2]); 144 err |= __put_user(0, &oact->sa_mask.sig[3]); 145 if (err) 146 return -EFAULT; 147 } 148 149 return ret; 150 } 151 #endif 152 153 asmlinkage int sys_sigaltstack(nabi_no_regargs struct pt_regs regs) 154 { 155 const stack_t __user *uss = (const stack_t __user *) regs.regs[4]; 156 stack_t __user *uoss = (stack_t __user *) regs.regs[5]; 157 unsigned long usp = regs.regs[29]; 158 159 return do_sigaltstack(uss, uoss, usp); 160 } 161 162 /* 163 * Horribly complicated - with the bloody RM9000 workarounds enabled 164 * the signal trampolines is moving to the end of the structure so we can 165 * increase the alignment without breaking software compatibility. 166 */ 167 #ifdef CONFIG_TRAD_SIGNALS 168 struct sigframe { 169 u32 sf_ass[4]; /* argument save space for o32 */ 170 #if ICACHE_REFILLS_WORKAROUND_WAR 171 u32 sf_pad[2]; 172 #else 173 u32 sf_code[2]; /* signal trampoline */ 174 #endif 175 struct sigcontext sf_sc; 176 sigset_t sf_mask; 177 #if ICACHE_REFILLS_WORKAROUND_WAR 178 u32 sf_code[8] ____cacheline_aligned; /* signal trampoline */ 179 #endif 180 }; 181 #endif 182 183 struct rt_sigframe { 184 u32 rs_ass[4]; /* argument save space for o32 */ 185 #if ICACHE_REFILLS_WORKAROUND_WAR 186 u32 rs_pad[2]; 187 #else 188 u32 rs_code[2]; /* signal trampoline */ 189 #endif 190 struct siginfo rs_info; 191 struct ucontext rs_uc; 192 #if ICACHE_REFILLS_WORKAROUND_WAR 193 u32 rs_code[8] ____cacheline_aligned; /* signal trampoline */ 194 #endif 195 }; 196 197 #ifdef CONFIG_TRAD_SIGNALS 198 save_static_function(sys_sigreturn); 199 __attribute_used__ noinline static void 200 _sys_sigreturn(nabi_no_regargs struct pt_regs regs) 201 { 202 struct sigframe *frame; 203 sigset_t blocked; 204 205 frame = (struct sigframe *) regs.regs[29]; 206 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 207 goto badframe; 208 if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked))) 209 goto badframe; 210 211 sigdelsetmask(&blocked, ~_BLOCKABLE); 212 spin_lock_irq(¤t->sighand->siglock); 213 current->blocked = blocked; 214 recalc_sigpending(); 215 spin_unlock_irq(¤t->sighand->siglock); 216 217 if (restore_sigcontext(®s, &frame->sf_sc)) 218 goto badframe; 219 220 /* 221 * Don't let your children do this ... 222 */ 223 if (current_thread_info()->flags & TIF_SYSCALL_TRACE) 224 do_syscall_trace(®s, 1); 225 __asm__ __volatile__( 226 "move\t$29, %0\n\t" 227 "j\tsyscall_exit" 228 :/* no outputs */ 229 :"r" (®s)); 230 /* Unreached */ 231 232 badframe: 233 force_sig(SIGSEGV, current); 234 } 235 #endif /* CONFIG_TRAD_SIGNALS */ 236 237 save_static_function(sys_rt_sigreturn); 238 __attribute_used__ noinline static void 239 _sys_rt_sigreturn(nabi_no_regargs struct pt_regs regs) 240 { 241 struct rt_sigframe *frame; 242 sigset_t set; 243 stack_t st; 244 245 frame = (struct rt_sigframe *) regs.regs[29]; 246 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 247 goto badframe; 248 if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set))) 249 goto badframe; 250 251 sigdelsetmask(&set, ~_BLOCKABLE); 252 spin_lock_irq(¤t->sighand->siglock); 253 current->blocked = set; 254 recalc_sigpending(); 255 spin_unlock_irq(¤t->sighand->siglock); 256 257 if (restore_sigcontext(®s, &frame->rs_uc.uc_mcontext)) 258 goto badframe; 259 260 if (__copy_from_user(&st, &frame->rs_uc.uc_stack, sizeof(st))) 261 goto badframe; 262 /* It is more difficult to avoid calling this function than to 263 call it and ignore errors. */ 264 do_sigaltstack(&st, NULL, regs.regs[29]); 265 266 /* 267 * Don't let your children do this ... 268 */ 269 __asm__ __volatile__( 270 "move\t$29, %0\n\t" 271 "j\tsyscall_exit" 272 :/* no outputs */ 273 :"r" (®s)); 274 /* Unreached */ 275 276 badframe: 277 force_sig(SIGSEGV, current); 278 } 279 280 #ifdef CONFIG_TRAD_SIGNALS 281 int setup_frame(struct k_sigaction * ka, struct pt_regs *regs, 282 int signr, sigset_t *set) 283 { 284 struct sigframe *frame; 285 int err = 0; 286 287 frame = get_sigframe(ka, regs, sizeof(*frame)); 288 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame))) 289 goto give_sigsegv; 290 291 install_sigtramp(frame->sf_code, __NR_sigreturn); 292 293 err |= setup_sigcontext(regs, &frame->sf_sc); 294 err |= __copy_to_user(&frame->sf_mask, set, sizeof(*set)); 295 if (err) 296 goto give_sigsegv; 297 298 /* 299 * Arguments to signal handler: 300 * 301 * a0 = signal number 302 * a1 = 0 (should be cause) 303 * a2 = pointer to struct sigcontext 304 * 305 * $25 and c0_epc point to the signal handler, $29 points to the 306 * struct sigframe. 307 */ 308 regs->regs[ 4] = signr; 309 regs->regs[ 5] = 0; 310 regs->regs[ 6] = (unsigned long) &frame->sf_sc; 311 regs->regs[29] = (unsigned long) frame; 312 regs->regs[31] = (unsigned long) frame->sf_code; 313 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler; 314 315 #if DEBUG_SIG 316 printk("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%p\n", 317 current->comm, current->pid, 318 frame, regs->cp0_epc, frame->regs[31]); 319 #endif 320 return 1; 321 322 give_sigsegv: 323 force_sigsegv(signr, current); 324 return 0; 325 } 326 #endif 327 328 int setup_rt_frame(struct k_sigaction * ka, struct pt_regs *regs, 329 int signr, sigset_t *set, siginfo_t *info) 330 { 331 struct rt_sigframe *frame; 332 int err = 0; 333 334 frame = get_sigframe(ka, regs, sizeof(*frame)); 335 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame))) 336 goto give_sigsegv; 337 338 install_sigtramp(frame->rs_code, __NR_rt_sigreturn); 339 340 /* Create siginfo. */ 341 err |= copy_siginfo_to_user(&frame->rs_info, info); 342 343 /* Create the ucontext. */ 344 err |= __put_user(0, &frame->rs_uc.uc_flags); 345 err |= __put_user(0, &frame->rs_uc.uc_link); 346 err |= __put_user((void *)current->sas_ss_sp, 347 &frame->rs_uc.uc_stack.ss_sp); 348 err |= __put_user(sas_ss_flags(regs->regs[29]), 349 &frame->rs_uc.uc_stack.ss_flags); 350 err |= __put_user(current->sas_ss_size, 351 &frame->rs_uc.uc_stack.ss_size); 352 err |= setup_sigcontext(regs, &frame->rs_uc.uc_mcontext); 353 err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set)); 354 355 if (err) 356 goto give_sigsegv; 357 358 /* 359 * Arguments to signal handler: 360 * 361 * a0 = signal number 362 * a1 = 0 (should be cause) 363 * a2 = pointer to ucontext 364 * 365 * $25 and c0_epc point to the signal handler, $29 points to 366 * the struct rt_sigframe. 367 */ 368 regs->regs[ 4] = signr; 369 regs->regs[ 5] = (unsigned long) &frame->rs_info; 370 regs->regs[ 6] = (unsigned long) &frame->rs_uc; 371 regs->regs[29] = (unsigned long) frame; 372 regs->regs[31] = (unsigned long) frame->rs_code; 373 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler; 374 375 #if DEBUG_SIG 376 printk("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%p\n", 377 current->comm, current->pid, 378 frame, regs->cp0_epc, regs->regs[31]); 379 #endif 380 return 1; 381 382 give_sigsegv: 383 force_sigsegv(signr, current); 384 return 0; 385 } 386 387 extern void setup_rt_frame_n32(struct k_sigaction * ka, 388 struct pt_regs *regs, int signr, sigset_t *set, siginfo_t *info); 389 390 static inline int handle_signal(unsigned long sig, siginfo_t *info, 391 struct k_sigaction *ka, sigset_t *oldset, struct pt_regs *regs) 392 { 393 int ret; 394 395 switch(regs->regs[0]) { 396 case ERESTART_RESTARTBLOCK: 397 case ERESTARTNOHAND: 398 regs->regs[2] = EINTR; 399 break; 400 case ERESTARTSYS: 401 if(!(ka->sa.sa_flags & SA_RESTART)) { 402 regs->regs[2] = EINTR; 403 break; 404 } 405 /* fallthrough */ 406 case ERESTARTNOINTR: /* Userland will reload $v0. */ 407 regs->regs[7] = regs->regs[26]; 408 regs->cp0_epc -= 8; 409 } 410 411 regs->regs[0] = 0; /* Don't deal with this again. */ 412 413 if (sig_uses_siginfo(ka)) 414 ret = current->thread.abi->setup_rt_frame(ka, regs, sig, oldset, info); 415 else 416 ret = current->thread.abi->setup_frame(ka, regs, sig, oldset); 417 418 spin_lock_irq(¤t->sighand->siglock); 419 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask); 420 if (!(ka->sa.sa_flags & SA_NODEFER)) 421 sigaddset(¤t->blocked,sig); 422 recalc_sigpending(); 423 spin_unlock_irq(¤t->sighand->siglock); 424 425 return ret; 426 } 427 428 int do_signal(sigset_t *oldset, struct pt_regs *regs) 429 { 430 struct k_sigaction ka; 431 siginfo_t info; 432 int signr; 433 434 /* 435 * We want the common case to go fast, which is why we may in certain 436 * cases get here from kernel mode. Just return without doing anything 437 * if so. 438 */ 439 if (!user_mode(regs)) 440 return 1; 441 442 if (try_to_freeze()) 443 goto no_signal; 444 445 if (!oldset) 446 oldset = ¤t->blocked; 447 448 signr = get_signal_to_deliver(&info, &ka, regs, NULL); 449 if (signr > 0) 450 return handle_signal(signr, &info, &ka, oldset, regs); 451 452 no_signal: 453 /* 454 * Who's code doesn't conform to the restartable syscall convention 455 * dies here!!! The li instruction, a single machine instruction, 456 * must directly be followed by the syscall instruction. 457 */ 458 if (regs->regs[0]) { 459 if (regs->regs[2] == ERESTARTNOHAND || 460 regs->regs[2] == ERESTARTSYS || 461 regs->regs[2] == ERESTARTNOINTR) { 462 regs->regs[7] = regs->regs[26]; 463 regs->cp0_epc -= 8; 464 } 465 if (regs->regs[2] == ERESTART_RESTARTBLOCK) { 466 regs->regs[2] = __NR_restart_syscall; 467 regs->regs[7] = regs->regs[26]; 468 regs->cp0_epc -= 4; 469 } 470 } 471 return 0; 472 } 473 474 /* 475 * notification of userspace execution resumption 476 * - triggered by current->work.notify_resume 477 */ 478 asmlinkage void do_notify_resume(struct pt_regs *regs, sigset_t *oldset, 479 __u32 thread_info_flags) 480 { 481 /* deal with pending signal delivery */ 482 if (thread_info_flags & _TIF_SIGPENDING) { 483 current->thread.abi->do_signal(oldset, regs); 484 } 485 } 486