1 /* 2 * OpenRISC signal.c 3 * 4 * Linux architectural port borrowing liberally from similar works of 5 * others. All original copyrights apply as per the original source 6 * declaration. 7 * 8 * Modifications for the OpenRISC architecture: 9 * Copyright (C) 2003 Matjaz Breskvar <phoenix@bsemi.com> 10 * Copyright (C) 2010-2011 Jonas Bonn <jonas@southpole.se> 11 * 12 * This program is free software; you can redistribute it and/or 13 * modify it under the terms of the GNU General Public License 14 * as published by the Free Software Foundation; either version 15 * 2 of the License, or (at your option) any later version. 16 */ 17 18 #include <linux/sched.h> 19 #include <linux/mm.h> 20 #include <linux/smp.h> 21 #include <linux/kernel.h> 22 #include <linux/signal.h> 23 #include <linux/errno.h> 24 #include <linux/wait.h> 25 #include <linux/ptrace.h> 26 #include <linux/unistd.h> 27 #include <linux/stddef.h> 28 #include <linux/tracehook.h> 29 30 #include <asm/processor.h> 31 #include <asm/ucontext.h> 32 #include <asm/uaccess.h> 33 34 #define DEBUG_SIG 0 35 36 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) 37 38 asmlinkage long 39 _sys_sigaltstack(const stack_t *uss, stack_t *uoss, struct pt_regs *regs) 40 { 41 return do_sigaltstack(uss, uoss, regs->sp); 42 } 43 44 struct rt_sigframe { 45 struct siginfo *pinfo; 46 void *puc; 47 struct siginfo info; 48 struct ucontext uc; 49 unsigned char retcode[16]; /* trampoline code */ 50 }; 51 52 static int restore_sigcontext(struct pt_regs *regs, struct sigcontext *sc) 53 { 54 unsigned int err = 0; 55 56 /* Alwys make any pending restarted system call return -EINTR */ 57 current_thread_info()->restart_block.fn = do_no_restart_syscall; 58 59 /* 60 * Restore the regs from &sc->regs. 61 * (sc is already checked for VERIFY_READ since the sigframe was 62 * checked in sys_sigreturn previously) 63 */ 64 if (__copy_from_user(regs, sc->regs.gpr, 32 * sizeof(unsigned long))) 65 goto badframe; 66 if (__copy_from_user(®s->pc, &sc->regs.pc, sizeof(unsigned long))) 67 goto badframe; 68 if (__copy_from_user(®s->sr, &sc->regs.sr, sizeof(unsigned long))) 69 goto badframe; 70 71 /* make sure the SM-bit is cleared so user-mode cannot fool us */ 72 regs->sr &= ~SPR_SR_SM; 73 74 /* TODO: the other ports use regs->orig_XX to disable syscall checks 75 * after this completes, but we don't use that mechanism. maybe we can 76 * use it now ? 77 */ 78 79 return err; 80 81 badframe: 82 return 1; 83 } 84 85 asmlinkage long _sys_rt_sigreturn(struct pt_regs *regs) 86 { 87 struct rt_sigframe *frame = (struct rt_sigframe __user *)regs->sp; 88 sigset_t set; 89 stack_t st; 90 91 /* 92 * Since we stacked the signal on a dword boundary, 93 * then frame should be dword aligned here. If it's 94 * not, then the user is trying to mess with us. 95 */ 96 if (((long)frame) & 3) 97 goto badframe; 98 99 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 100 goto badframe; 101 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) 102 goto badframe; 103 104 sigdelsetmask(&set, ~_BLOCKABLE); 105 spin_lock_irq(¤t->sighand->siglock); 106 current->blocked = set; 107 recalc_sigpending(); 108 spin_unlock_irq(¤t->sighand->siglock); 109 110 if (restore_sigcontext(regs, &frame->uc.uc_mcontext)) 111 goto badframe; 112 113 if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st))) 114 goto badframe; 115 /* It is more difficult to avoid calling this function than to 116 call it and ignore errors. */ 117 do_sigaltstack(&st, NULL, regs->sp); 118 119 return regs->gpr[11]; 120 121 badframe: 122 force_sig(SIGSEGV, current); 123 return 0; 124 } 125 126 /* 127 * Set up a signal frame. 128 */ 129 130 static int setup_sigcontext(struct sigcontext *sc, struct pt_regs *regs, 131 unsigned long mask) 132 { 133 int err = 0; 134 135 /* copy the regs */ 136 137 err |= __copy_to_user(sc->regs.gpr, regs, 32 * sizeof(unsigned long)); 138 err |= __copy_to_user(&sc->regs.pc, ®s->pc, sizeof(unsigned long)); 139 err |= __copy_to_user(&sc->regs.sr, ®s->sr, sizeof(unsigned long)); 140 141 /* then some other stuff */ 142 143 err |= __put_user(mask, &sc->oldmask); 144 145 return err; 146 } 147 148 static inline unsigned long align_sigframe(unsigned long sp) 149 { 150 return sp & ~3UL; 151 } 152 153 /* 154 * Work out where the signal frame should go. It's either on the user stack 155 * or the alternate stack. 156 */ 157 158 static inline void __user *get_sigframe(struct k_sigaction *ka, 159 struct pt_regs *regs, size_t frame_size) 160 { 161 unsigned long sp = regs->sp; 162 int onsigstack = on_sig_stack(sp); 163 164 /* redzone */ 165 sp -= STACK_FRAME_OVERHEAD; 166 167 /* This is the X/Open sanctioned signal stack switching. */ 168 if ((ka->sa.sa_flags & SA_ONSTACK) && !onsigstack) { 169 if (current->sas_ss_size) 170 sp = current->sas_ss_sp + current->sas_ss_size; 171 } 172 173 sp = align_sigframe(sp - frame_size); 174 175 /* 176 * If we are on the alternate signal stack and would overflow it, don't. 177 * Return an always-bogus address instead so we will die with SIGSEGV. 178 */ 179 if (onsigstack && !likely(on_sig_stack(sp))) 180 return (void __user *)-1L; 181 182 return (void __user *)sp; 183 } 184 185 /* grab and setup a signal frame. 186 * 187 * basically we stack a lot of state info, and arrange for the 188 * user-mode program to return to the kernel using either a 189 * trampoline which performs the syscall sigreturn, or a provided 190 * user-mode trampoline. 191 */ 192 static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, 193 sigset_t *set, struct pt_regs *regs) 194 { 195 struct rt_sigframe *frame; 196 unsigned long return_ip; 197 int err = 0; 198 199 frame = get_sigframe(ka, regs, sizeof(*frame)); 200 201 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) 202 goto give_sigsegv; 203 204 err |= __put_user(&frame->info, &frame->pinfo); 205 err |= __put_user(&frame->uc, &frame->puc); 206 207 if (ka->sa.sa_flags & SA_SIGINFO) 208 err |= copy_siginfo_to_user(&frame->info, info); 209 if (err) 210 goto give_sigsegv; 211 212 /* Clear all the bits of the ucontext we don't use. */ 213 err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext)); 214 err |= __put_user(0, &frame->uc.uc_flags); 215 err |= __put_user(NULL, &frame->uc.uc_link); 216 err |= __put_user((void *)current->sas_ss_sp, 217 &frame->uc.uc_stack.ss_sp); 218 err |= __put_user(sas_ss_flags(regs->sp), &frame->uc.uc_stack.ss_flags); 219 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size); 220 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, set->sig[0]); 221 222 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 223 224 if (err) 225 goto give_sigsegv; 226 227 /* trampoline - the desired return ip is the retcode itself */ 228 return_ip = (unsigned long)&frame->retcode; 229 /* This is l.ori r11,r0,__NR_sigreturn, l.sys 1 */ 230 err |= __put_user(0xa960, (short *)(frame->retcode + 0)); 231 err |= __put_user(__NR_rt_sigreturn, (short *)(frame->retcode + 2)); 232 err |= __put_user(0x20000001, (unsigned long *)(frame->retcode + 4)); 233 err |= __put_user(0x15000000, (unsigned long *)(frame->retcode + 8)); 234 235 if (err) 236 goto give_sigsegv; 237 238 /* TODO what is the current->exec_domain stuff and invmap ? */ 239 240 /* Set up registers for signal handler */ 241 regs->pc = (unsigned long)ka->sa.sa_handler; /* what we enter NOW */ 242 regs->gpr[9] = (unsigned long)return_ip; /* what we enter LATER */ 243 regs->gpr[3] = (unsigned long)sig; /* arg 1: signo */ 244 regs->gpr[4] = (unsigned long)&frame->info; /* arg 2: (siginfo_t*) */ 245 regs->gpr[5] = (unsigned long)&frame->uc; /* arg 3: ucontext */ 246 247 /* actually move the usp to reflect the stacked frame */ 248 regs->sp = (unsigned long)frame; 249 250 return; 251 252 give_sigsegv: 253 if (sig == SIGSEGV) 254 ka->sa.sa_handler = SIG_DFL; 255 force_sig(SIGSEGV, current); 256 } 257 258 static inline void 259 handle_signal(unsigned long sig, 260 siginfo_t *info, struct k_sigaction *ka, 261 sigset_t *oldset, struct pt_regs *regs) 262 { 263 setup_rt_frame(sig, ka, info, oldset, regs); 264 265 if (ka->sa.sa_flags & SA_ONESHOT) 266 ka->sa.sa_handler = SIG_DFL; 267 268 spin_lock_irq(¤t->sighand->siglock); 269 sigorsets(¤t->blocked, ¤t->blocked, &ka->sa.sa_mask); 270 if (!(ka->sa.sa_flags & SA_NODEFER)) 271 sigaddset(¤t->blocked, sig); 272 recalc_sigpending(); 273 274 spin_unlock_irq(¤t->sighand->siglock); 275 } 276 277 /* 278 * Note that 'init' is a special process: it doesn't get signals it doesn't 279 * want to handle. Thus you cannot kill init even with a SIGKILL even by 280 * mistake. 281 * 282 * Also note that the regs structure given here as an argument, is the latest 283 * pushed pt_regs. It may or may not be the same as the first pushed registers 284 * when the initial usermode->kernelmode transition took place. Therefore 285 * we can use user_mode(regs) to see if we came directly from kernel or user 286 * mode below. 287 */ 288 289 void do_signal(struct pt_regs *regs) 290 { 291 siginfo_t info; 292 int signr; 293 struct k_sigaction ka; 294 295 /* 296 * We want the common case to go fast, which 297 * is why we may in certain cases get here from 298 * kernel mode. Just return without doing anything 299 * if so. 300 */ 301 if (!user_mode(regs)) 302 return; 303 304 signr = get_signal_to_deliver(&info, &ka, regs, NULL); 305 306 /* If we are coming out of a syscall then we need 307 * to check if the syscall was interrupted and wants to be 308 * restarted after handling the signal. If so, the original 309 * syscall number is put back into r11 and the PC rewound to 310 * point at the l.sys instruction that resulted in the 311 * original syscall. Syscall results other than the four 312 * below mean that the syscall executed to completion and no 313 * restart is necessary. 314 */ 315 if (regs->syscallno) { 316 int restart = 0; 317 318 switch (regs->gpr[11]) { 319 case -ERESTART_RESTARTBLOCK: 320 case -ERESTARTNOHAND: 321 /* Restart if there is no signal handler */ 322 restart = (signr <= 0); 323 break; 324 case -ERESTARTSYS: 325 /* Restart if there no signal handler or 326 * SA_RESTART flag is set */ 327 restart = (signr <= 0 || (ka.sa.sa_flags & SA_RESTART)); 328 break; 329 case -ERESTARTNOINTR: 330 /* Always restart */ 331 restart = 1; 332 break; 333 } 334 335 if (restart) { 336 if (regs->gpr[11] == -ERESTART_RESTARTBLOCK) 337 regs->gpr[11] = __NR_restart_syscall; 338 else 339 regs->gpr[11] = regs->orig_gpr11; 340 regs->pc -= 4; 341 } else { 342 regs->gpr[11] = -EINTR; 343 } 344 } 345 346 if (signr <= 0) { 347 /* no signal to deliver so we just put the saved sigmask 348 * back */ 349 if (test_thread_flag(TIF_RESTORE_SIGMASK)) { 350 clear_thread_flag(TIF_RESTORE_SIGMASK); 351 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL); 352 } 353 354 } else { /* signr > 0 */ 355 sigset_t *oldset; 356 357 if (current_thread_info()->flags & _TIF_RESTORE_SIGMASK) 358 oldset = ¤t->saved_sigmask; 359 else 360 oldset = ¤t->blocked; 361 362 /* Whee! Actually deliver the signal. */ 363 handle_signal(signr, &info, &ka, oldset, regs); 364 /* a signal was successfully delivered; the saved 365 * sigmask will have been stored in the signal frame, 366 * and will be restored by sigreturn, so we can simply 367 * clear the TIF_RESTORE_SIGMASK flag */ 368 if (test_thread_flag(TIF_RESTORE_SIGMASK)) 369 clear_thread_flag(TIF_RESTORE_SIGMASK); 370 371 tracehook_signal_handler(signr, &info, &ka, regs, 372 test_thread_flag(TIF_SINGLESTEP)); 373 } 374 375 return; 376 } 377 378 asmlinkage void do_notify_resume(struct pt_regs *regs) 379 { 380 if (current_thread_info()->flags & _TIF_SIGPENDING) 381 do_signal(regs); 382 383 if (current_thread_info()->flags & _TIF_NOTIFY_RESUME) { 384 clear_thread_flag(TIF_NOTIFY_RESUME); 385 tracehook_notify_resume(regs); 386 if (current->replacement_session_keyring) 387 key_replace_session_keyring(); 388 } 389 } 390