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 set_current_blocked(&set); 106 107 if (restore_sigcontext(regs, &frame->uc.uc_mcontext)) 108 goto badframe; 109 110 if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st))) 111 goto badframe; 112 /* It is more difficult to avoid calling this function than to 113 call it and ignore errors. */ 114 do_sigaltstack(&st, NULL, regs->sp); 115 116 return regs->gpr[11]; 117 118 badframe: 119 force_sig(SIGSEGV, current); 120 return 0; 121 } 122 123 /* 124 * Set up a signal frame. 125 */ 126 127 static int setup_sigcontext(struct sigcontext *sc, struct pt_regs *regs, 128 unsigned long mask) 129 { 130 int err = 0; 131 132 /* copy the regs */ 133 134 err |= __copy_to_user(sc->regs.gpr, regs, 32 * sizeof(unsigned long)); 135 err |= __copy_to_user(&sc->regs.pc, ®s->pc, sizeof(unsigned long)); 136 err |= __copy_to_user(&sc->regs.sr, ®s->sr, sizeof(unsigned long)); 137 138 /* then some other stuff */ 139 140 err |= __put_user(mask, &sc->oldmask); 141 142 return err; 143 } 144 145 static inline unsigned long align_sigframe(unsigned long sp) 146 { 147 return sp & ~3UL; 148 } 149 150 /* 151 * Work out where the signal frame should go. It's either on the user stack 152 * or the alternate stack. 153 */ 154 155 static inline void __user *get_sigframe(struct k_sigaction *ka, 156 struct pt_regs *regs, size_t frame_size) 157 { 158 unsigned long sp = regs->sp; 159 int onsigstack = on_sig_stack(sp); 160 161 /* redzone */ 162 sp -= STACK_FRAME_OVERHEAD; 163 164 /* This is the X/Open sanctioned signal stack switching. */ 165 if ((ka->sa.sa_flags & SA_ONSTACK) && !onsigstack) { 166 if (current->sas_ss_size) 167 sp = current->sas_ss_sp + current->sas_ss_size; 168 } 169 170 sp = align_sigframe(sp - frame_size); 171 172 /* 173 * If we are on the alternate signal stack and would overflow it, don't. 174 * Return an always-bogus address instead so we will die with SIGSEGV. 175 */ 176 if (onsigstack && !likely(on_sig_stack(sp))) 177 return (void __user *)-1L; 178 179 return (void __user *)sp; 180 } 181 182 /* grab and setup a signal frame. 183 * 184 * basically we stack a lot of state info, and arrange for the 185 * user-mode program to return to the kernel using either a 186 * trampoline which performs the syscall sigreturn, or a provided 187 * user-mode trampoline. 188 */ 189 static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, 190 sigset_t *set, struct pt_regs *regs) 191 { 192 struct rt_sigframe *frame; 193 unsigned long return_ip; 194 int err = 0; 195 196 frame = get_sigframe(ka, regs, sizeof(*frame)); 197 198 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) 199 goto give_sigsegv; 200 201 err |= __put_user(&frame->info, &frame->pinfo); 202 err |= __put_user(&frame->uc, &frame->puc); 203 204 if (ka->sa.sa_flags & SA_SIGINFO) 205 err |= copy_siginfo_to_user(&frame->info, info); 206 if (err) 207 goto give_sigsegv; 208 209 /* Clear all the bits of the ucontext we don't use. */ 210 err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext)); 211 err |= __put_user(0, &frame->uc.uc_flags); 212 err |= __put_user(NULL, &frame->uc.uc_link); 213 err |= __put_user((void *)current->sas_ss_sp, 214 &frame->uc.uc_stack.ss_sp); 215 err |= __put_user(sas_ss_flags(regs->sp), &frame->uc.uc_stack.ss_flags); 216 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size); 217 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, set->sig[0]); 218 219 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 220 221 if (err) 222 goto give_sigsegv; 223 224 /* trampoline - the desired return ip is the retcode itself */ 225 return_ip = (unsigned long)&frame->retcode; 226 /* This is l.ori r11,r0,__NR_sigreturn, l.sys 1 */ 227 err |= __put_user(0xa960, (short *)(frame->retcode + 0)); 228 err |= __put_user(__NR_rt_sigreturn, (short *)(frame->retcode + 2)); 229 err |= __put_user(0x20000001, (unsigned long *)(frame->retcode + 4)); 230 err |= __put_user(0x15000000, (unsigned long *)(frame->retcode + 8)); 231 232 if (err) 233 goto give_sigsegv; 234 235 /* TODO what is the current->exec_domain stuff and invmap ? */ 236 237 /* Set up registers for signal handler */ 238 regs->pc = (unsigned long)ka->sa.sa_handler; /* what we enter NOW */ 239 regs->gpr[9] = (unsigned long)return_ip; /* what we enter LATER */ 240 regs->gpr[3] = (unsigned long)sig; /* arg 1: signo */ 241 regs->gpr[4] = (unsigned long)&frame->info; /* arg 2: (siginfo_t*) */ 242 regs->gpr[5] = (unsigned long)&frame->uc; /* arg 3: ucontext */ 243 244 /* actually move the usp to reflect the stacked frame */ 245 regs->sp = (unsigned long)frame; 246 247 return 0; 248 249 give_sigsegv: 250 force_sigsegv(sig, current); 251 return -EFAULT; 252 } 253 254 static inline int 255 handle_signal(unsigned long sig, 256 siginfo_t *info, struct k_sigaction *ka, 257 sigset_t *oldset, struct pt_regs *regs) 258 { 259 int ret; 260 261 ret = setup_rt_frame(sig, ka, info, oldset, regs); 262 if (ret) 263 return ret; 264 265 block_sigmask(ka, sig); 266 267 return 0; 268 } 269 270 /* 271 * Note that 'init' is a special process: it doesn't get signals it doesn't 272 * want to handle. Thus you cannot kill init even with a SIGKILL even by 273 * mistake. 274 * 275 * Also note that the regs structure given here as an argument, is the latest 276 * pushed pt_regs. It may or may not be the same as the first pushed registers 277 * when the initial usermode->kernelmode transition took place. Therefore 278 * we can use user_mode(regs) to see if we came directly from kernel or user 279 * mode below. 280 */ 281 282 void do_signal(struct pt_regs *regs) 283 { 284 siginfo_t info; 285 int signr; 286 struct k_sigaction ka; 287 288 /* 289 * We want the common case to go fast, which 290 * is why we may in certain cases get here from 291 * kernel mode. Just return without doing anything 292 * if so. 293 */ 294 if (!user_mode(regs)) 295 return; 296 297 signr = get_signal_to_deliver(&info, &ka, regs, NULL); 298 299 /* If we are coming out of a syscall then we need 300 * to check if the syscall was interrupted and wants to be 301 * restarted after handling the signal. If so, the original 302 * syscall number is put back into r11 and the PC rewound to 303 * point at the l.sys instruction that resulted in the 304 * original syscall. Syscall results other than the four 305 * below mean that the syscall executed to completion and no 306 * restart is necessary. 307 */ 308 if (regs->orig_gpr11) { 309 int restart = 0; 310 311 switch (regs->gpr[11]) { 312 case -ERESTART_RESTARTBLOCK: 313 case -ERESTARTNOHAND: 314 /* Restart if there is no signal handler */ 315 restart = (signr <= 0); 316 break; 317 case -ERESTARTSYS: 318 /* Restart if there no signal handler or 319 * SA_RESTART flag is set */ 320 restart = (signr <= 0 || (ka.sa.sa_flags & SA_RESTART)); 321 break; 322 case -ERESTARTNOINTR: 323 /* Always restart */ 324 restart = 1; 325 break; 326 } 327 328 if (restart) { 329 if (regs->gpr[11] == -ERESTART_RESTARTBLOCK) 330 regs->gpr[11] = __NR_restart_syscall; 331 else 332 regs->gpr[11] = regs->orig_gpr11; 333 regs->pc -= 4; 334 } else { 335 regs->gpr[11] = -EINTR; 336 } 337 } 338 339 if (signr <= 0) { 340 /* no signal to deliver so we just put the saved sigmask 341 * back */ 342 if (test_thread_flag(TIF_RESTORE_SIGMASK)) { 343 clear_thread_flag(TIF_RESTORE_SIGMASK); 344 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL); 345 } 346 347 } else { /* signr > 0 */ 348 sigset_t *oldset; 349 350 if (current_thread_info()->flags & _TIF_RESTORE_SIGMASK) 351 oldset = ¤t->saved_sigmask; 352 else 353 oldset = ¤t->blocked; 354 355 /* Whee! Actually deliver the signal. */ 356 if (!handle_signal(signr, &info, &ka, oldset, regs)) { 357 /* a signal was successfully delivered; the saved 358 * sigmask will have been stored in the signal frame, 359 * and will be restored by sigreturn, so we can simply 360 * clear the TIF_RESTORE_SIGMASK flag */ 361 clear_thread_flag(TIF_RESTORE_SIGMASK); 362 } 363 364 tracehook_signal_handler(signr, &info, &ka, regs, 365 test_thread_flag(TIF_SINGLESTEP)); 366 } 367 368 return; 369 } 370 371 asmlinkage void do_notify_resume(struct pt_regs *regs) 372 { 373 if (current_thread_info()->flags & _TIF_SIGPENDING) 374 do_signal(regs); 375 376 if (current_thread_info()->flags & _TIF_NOTIFY_RESUME) { 377 clear_thread_flag(TIF_NOTIFY_RESUME); 378 tracehook_notify_resume(regs); 379 if (current->replacement_session_keyring) 380 key_replace_session_keyring(); 381 } 382 } 383