1 /*
2 * linux/arch/arm/kernel/signal.c
3 *
4 * Copyright (C) 1995-2009 Russell King
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 version 2 as
8 * published by the Free Software Foundation.
9 */
10 #include <linux/errno.h>
11 #include <linux/random.h>
12 #include <linux/signal.h>
13 #include <linux/personality.h>
14 #include <linux/uaccess.h>
15 #include <linux/tracehook.h>
16 #include <linux/uprobes.h>
17
18 #include <asm/elf.h>
19 #include <asm/cacheflush.h>
20 #include <asm/traps.h>
21 #include <asm/ucontext.h>
22 #include <asm/unistd.h>
23 #include <asm/vfp.h>
24
25 extern const unsigned long sigreturn_codes[7];
26
27 static unsigned long signal_return_offset;
28
29 #ifdef CONFIG_CRUNCH
preserve_crunch_context(struct crunch_sigframe __user * frame)30 static int preserve_crunch_context(struct crunch_sigframe __user *frame)
31 {
32 char kbuf[sizeof(*frame) + 8];
33 struct crunch_sigframe *kframe;
34
35 /* the crunch context must be 64 bit aligned */
36 kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7);
37 kframe->magic = CRUNCH_MAGIC;
38 kframe->size = CRUNCH_STORAGE_SIZE;
39 crunch_task_copy(current_thread_info(), &kframe->storage);
40 return __copy_to_user(frame, kframe, sizeof(*frame));
41 }
42
restore_crunch_context(struct crunch_sigframe __user * frame)43 static int restore_crunch_context(struct crunch_sigframe __user *frame)
44 {
45 char kbuf[sizeof(*frame) + 8];
46 struct crunch_sigframe *kframe;
47
48 /* the crunch context must be 64 bit aligned */
49 kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7);
50 if (__copy_from_user(kframe, frame, sizeof(*frame)))
51 return -1;
52 if (kframe->magic != CRUNCH_MAGIC ||
53 kframe->size != CRUNCH_STORAGE_SIZE)
54 return -1;
55 crunch_task_restore(current_thread_info(), &kframe->storage);
56 return 0;
57 }
58 #endif
59
60 #ifdef CONFIG_IWMMXT
61
preserve_iwmmxt_context(struct iwmmxt_sigframe * frame)62 static int preserve_iwmmxt_context(struct iwmmxt_sigframe *frame)
63 {
64 char kbuf[sizeof(*frame) + 8];
65 struct iwmmxt_sigframe *kframe;
66
67 /* the iWMMXt context must be 64 bit aligned */
68 kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7);
69 kframe->magic = IWMMXT_MAGIC;
70 kframe->size = IWMMXT_STORAGE_SIZE;
71 iwmmxt_task_copy(current_thread_info(), &kframe->storage);
72 return __copy_to_user(frame, kframe, sizeof(*frame));
73 }
74
restore_iwmmxt_context(struct iwmmxt_sigframe * frame)75 static int restore_iwmmxt_context(struct iwmmxt_sigframe *frame)
76 {
77 char kbuf[sizeof(*frame) + 8];
78 struct iwmmxt_sigframe *kframe;
79
80 /* the iWMMXt context must be 64 bit aligned */
81 kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7);
82 if (__copy_from_user(kframe, frame, sizeof(*frame)))
83 return -1;
84 if (kframe->magic != IWMMXT_MAGIC ||
85 kframe->size != IWMMXT_STORAGE_SIZE)
86 return -1;
87 iwmmxt_task_restore(current_thread_info(), &kframe->storage);
88 return 0;
89 }
90
91 #endif
92
93 #ifdef CONFIG_VFP
94
preserve_vfp_context(struct vfp_sigframe __user * frame)95 static int preserve_vfp_context(struct vfp_sigframe __user *frame)
96 {
97 const unsigned long magic = VFP_MAGIC;
98 const unsigned long size = VFP_STORAGE_SIZE;
99 int err = 0;
100
101 __put_user_error(magic, &frame->magic, err);
102 __put_user_error(size, &frame->size, err);
103
104 if (err)
105 return -EFAULT;
106
107 return vfp_preserve_user_clear_hwstate(&frame->ufp, &frame->ufp_exc);
108 }
109
restore_vfp_context(struct vfp_sigframe __user * frame)110 static int restore_vfp_context(struct vfp_sigframe __user *frame)
111 {
112 unsigned long magic;
113 unsigned long size;
114 int err = 0;
115
116 __get_user_error(magic, &frame->magic, err);
117 __get_user_error(size, &frame->size, err);
118
119 if (err)
120 return -EFAULT;
121 if (magic != VFP_MAGIC || size != VFP_STORAGE_SIZE)
122 return -EINVAL;
123
124 return vfp_restore_user_hwstate(&frame->ufp, &frame->ufp_exc);
125 }
126
127 #endif
128
129 /*
130 * Do a signal return; undo the signal stack. These are aligned to 64-bit.
131 */
132 struct sigframe {
133 struct ucontext uc;
134 unsigned long retcode[2];
135 };
136
137 struct rt_sigframe {
138 struct siginfo info;
139 struct sigframe sig;
140 };
141
restore_sigframe(struct pt_regs * regs,struct sigframe __user * sf)142 static int restore_sigframe(struct pt_regs *regs, struct sigframe __user *sf)
143 {
144 struct aux_sigframe __user *aux;
145 sigset_t set;
146 int err;
147
148 err = __copy_from_user(&set, &sf->uc.uc_sigmask, sizeof(set));
149 if (err == 0)
150 set_current_blocked(&set);
151
152 __get_user_error(regs->ARM_r0, &sf->uc.uc_mcontext.arm_r0, err);
153 __get_user_error(regs->ARM_r1, &sf->uc.uc_mcontext.arm_r1, err);
154 __get_user_error(regs->ARM_r2, &sf->uc.uc_mcontext.arm_r2, err);
155 __get_user_error(regs->ARM_r3, &sf->uc.uc_mcontext.arm_r3, err);
156 __get_user_error(regs->ARM_r4, &sf->uc.uc_mcontext.arm_r4, err);
157 __get_user_error(regs->ARM_r5, &sf->uc.uc_mcontext.arm_r5, err);
158 __get_user_error(regs->ARM_r6, &sf->uc.uc_mcontext.arm_r6, err);
159 __get_user_error(regs->ARM_r7, &sf->uc.uc_mcontext.arm_r7, err);
160 __get_user_error(regs->ARM_r8, &sf->uc.uc_mcontext.arm_r8, err);
161 __get_user_error(regs->ARM_r9, &sf->uc.uc_mcontext.arm_r9, err);
162 __get_user_error(regs->ARM_r10, &sf->uc.uc_mcontext.arm_r10, err);
163 __get_user_error(regs->ARM_fp, &sf->uc.uc_mcontext.arm_fp, err);
164 __get_user_error(regs->ARM_ip, &sf->uc.uc_mcontext.arm_ip, err);
165 __get_user_error(regs->ARM_sp, &sf->uc.uc_mcontext.arm_sp, err);
166 __get_user_error(regs->ARM_lr, &sf->uc.uc_mcontext.arm_lr, err);
167 __get_user_error(regs->ARM_pc, &sf->uc.uc_mcontext.arm_pc, err);
168 __get_user_error(regs->ARM_cpsr, &sf->uc.uc_mcontext.arm_cpsr, err);
169
170 err |= !valid_user_regs(regs);
171
172 aux = (struct aux_sigframe __user *) sf->uc.uc_regspace;
173 #ifdef CONFIG_CRUNCH
174 if (err == 0)
175 err |= restore_crunch_context(&aux->crunch);
176 #endif
177 #ifdef CONFIG_IWMMXT
178 if (err == 0 && test_thread_flag(TIF_USING_IWMMXT))
179 err |= restore_iwmmxt_context(&aux->iwmmxt);
180 #endif
181 #ifdef CONFIG_VFP
182 if (err == 0)
183 err |= restore_vfp_context(&aux->vfp);
184 #endif
185
186 return err;
187 }
188
sys_sigreturn(struct pt_regs * regs)189 asmlinkage int sys_sigreturn(struct pt_regs *regs)
190 {
191 struct sigframe __user *frame;
192
193 /* Always make any pending restarted system calls return -EINTR */
194 current->restart_block.fn = do_no_restart_syscall;
195
196 /*
197 * Since we stacked the signal on a 64-bit boundary,
198 * then 'sp' should be word aligned here. If it's
199 * not, then the user is trying to mess with us.
200 */
201 if (regs->ARM_sp & 7)
202 goto badframe;
203
204 frame = (struct sigframe __user *)regs->ARM_sp;
205
206 if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
207 goto badframe;
208
209 if (restore_sigframe(regs, frame))
210 goto badframe;
211
212 return regs->ARM_r0;
213
214 badframe:
215 force_sig(SIGSEGV, current);
216 return 0;
217 }
218
sys_rt_sigreturn(struct pt_regs * regs)219 asmlinkage int sys_rt_sigreturn(struct pt_regs *regs)
220 {
221 struct rt_sigframe __user *frame;
222
223 /* Always make any pending restarted system calls return -EINTR */
224 current->restart_block.fn = do_no_restart_syscall;
225
226 /*
227 * Since we stacked the signal on a 64-bit boundary,
228 * then 'sp' should be word aligned here. If it's
229 * not, then the user is trying to mess with us.
230 */
231 if (regs->ARM_sp & 7)
232 goto badframe;
233
234 frame = (struct rt_sigframe __user *)regs->ARM_sp;
235
236 if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
237 goto badframe;
238
239 if (restore_sigframe(regs, &frame->sig))
240 goto badframe;
241
242 if (restore_altstack(&frame->sig.uc.uc_stack))
243 goto badframe;
244
245 return regs->ARM_r0;
246
247 badframe:
248 force_sig(SIGSEGV, current);
249 return 0;
250 }
251
252 static int
setup_sigframe(struct sigframe __user * sf,struct pt_regs * regs,sigset_t * set)253 setup_sigframe(struct sigframe __user *sf, struct pt_regs *regs, sigset_t *set)
254 {
255 struct aux_sigframe __user *aux;
256 int err = 0;
257
258 __put_user_error(regs->ARM_r0, &sf->uc.uc_mcontext.arm_r0, err);
259 __put_user_error(regs->ARM_r1, &sf->uc.uc_mcontext.arm_r1, err);
260 __put_user_error(regs->ARM_r2, &sf->uc.uc_mcontext.arm_r2, err);
261 __put_user_error(regs->ARM_r3, &sf->uc.uc_mcontext.arm_r3, err);
262 __put_user_error(regs->ARM_r4, &sf->uc.uc_mcontext.arm_r4, err);
263 __put_user_error(regs->ARM_r5, &sf->uc.uc_mcontext.arm_r5, err);
264 __put_user_error(regs->ARM_r6, &sf->uc.uc_mcontext.arm_r6, err);
265 __put_user_error(regs->ARM_r7, &sf->uc.uc_mcontext.arm_r7, err);
266 __put_user_error(regs->ARM_r8, &sf->uc.uc_mcontext.arm_r8, err);
267 __put_user_error(regs->ARM_r9, &sf->uc.uc_mcontext.arm_r9, err);
268 __put_user_error(regs->ARM_r10, &sf->uc.uc_mcontext.arm_r10, err);
269 __put_user_error(regs->ARM_fp, &sf->uc.uc_mcontext.arm_fp, err);
270 __put_user_error(regs->ARM_ip, &sf->uc.uc_mcontext.arm_ip, err);
271 __put_user_error(regs->ARM_sp, &sf->uc.uc_mcontext.arm_sp, err);
272 __put_user_error(regs->ARM_lr, &sf->uc.uc_mcontext.arm_lr, err);
273 __put_user_error(regs->ARM_pc, &sf->uc.uc_mcontext.arm_pc, err);
274 __put_user_error(regs->ARM_cpsr, &sf->uc.uc_mcontext.arm_cpsr, err);
275
276 __put_user_error(current->thread.trap_no, &sf->uc.uc_mcontext.trap_no, err);
277 __put_user_error(current->thread.error_code, &sf->uc.uc_mcontext.error_code, err);
278 __put_user_error(current->thread.address, &sf->uc.uc_mcontext.fault_address, err);
279 __put_user_error(set->sig[0], &sf->uc.uc_mcontext.oldmask, err);
280
281 err |= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(*set));
282
283 aux = (struct aux_sigframe __user *) sf->uc.uc_regspace;
284 #ifdef CONFIG_CRUNCH
285 if (err == 0)
286 err |= preserve_crunch_context(&aux->crunch);
287 #endif
288 #ifdef CONFIG_IWMMXT
289 if (err == 0 && test_thread_flag(TIF_USING_IWMMXT))
290 err |= preserve_iwmmxt_context(&aux->iwmmxt);
291 #endif
292 #ifdef CONFIG_VFP
293 if (err == 0)
294 err |= preserve_vfp_context(&aux->vfp);
295 #endif
296 __put_user_error(0, &aux->end_magic, err);
297
298 return err;
299 }
300
301 static inline void __user *
get_sigframe(struct ksignal * ksig,struct pt_regs * regs,int framesize)302 get_sigframe(struct ksignal *ksig, struct pt_regs *regs, int framesize)
303 {
304 unsigned long sp = sigsp(regs->ARM_sp, ksig);
305 void __user *frame;
306
307 /*
308 * ATPCS B01 mandates 8-byte alignment
309 */
310 frame = (void __user *)((sp - framesize) & ~7);
311
312 /*
313 * Check that we can actually write to the signal frame.
314 */
315 if (!access_ok(VERIFY_WRITE, frame, framesize))
316 frame = NULL;
317
318 return frame;
319 }
320
321 static int
setup_return(struct pt_regs * regs,struct ksignal * ksig,unsigned long __user * rc,void __user * frame)322 setup_return(struct pt_regs *regs, struct ksignal *ksig,
323 unsigned long __user *rc, void __user *frame)
324 {
325 unsigned long handler = (unsigned long)ksig->ka.sa.sa_handler;
326 unsigned long retcode;
327 int thumb = 0;
328 unsigned long cpsr = regs->ARM_cpsr & ~(PSR_f | PSR_E_BIT);
329
330 cpsr |= PSR_ENDSTATE;
331
332 /*
333 * Maybe we need to deliver a 32-bit signal to a 26-bit task.
334 */
335 if (ksig->ka.sa.sa_flags & SA_THIRTYTWO)
336 cpsr = (cpsr & ~MODE_MASK) | USR_MODE;
337
338 #ifdef CONFIG_ARM_THUMB
339 if (elf_hwcap & HWCAP_THUMB) {
340 /*
341 * The LSB of the handler determines if we're going to
342 * be using THUMB or ARM mode for this signal handler.
343 */
344 thumb = handler & 1;
345
346 #if __LINUX_ARM_ARCH__ >= 6
347 /*
348 * Clear the If-Then Thumb-2 execution state. ARM spec
349 * requires this to be all 000s in ARM mode. Snapdragon
350 * S4/Krait misbehaves on a Thumb=>ARM signal transition
351 * without this.
352 *
353 * We must do this whenever we are running on a Thumb-2
354 * capable CPU, which includes ARMv6T2. However, we elect
355 * to do this whenever we're on an ARMv6 or later CPU for
356 * simplicity.
357 */
358 cpsr &= ~PSR_IT_MASK;
359 #endif
360
361 if (thumb) {
362 cpsr |= PSR_T_BIT;
363 } else
364 cpsr &= ~PSR_T_BIT;
365 }
366 #endif
367
368 if (ksig->ka.sa.sa_flags & SA_RESTORER) {
369 retcode = (unsigned long)ksig->ka.sa.sa_restorer;
370 } else {
371 unsigned int idx = thumb << 1;
372
373 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
374 idx += 3;
375
376 /*
377 * Put the sigreturn code on the stack no matter which return
378 * mechanism we use in order to remain ABI compliant
379 */
380 if (__put_user(sigreturn_codes[idx], rc) ||
381 __put_user(sigreturn_codes[idx+1], rc+1))
382 return 1;
383
384 #ifdef CONFIG_MMU
385 if (cpsr & MODE32_BIT) {
386 struct mm_struct *mm = current->mm;
387
388 /*
389 * 32-bit code can use the signal return page
390 * except when the MPU has protected the vectors
391 * page from PL0
392 */
393 retcode = mm->context.sigpage + signal_return_offset +
394 (idx << 2) + thumb;
395 } else
396 #endif
397 {
398 /*
399 * Ensure that the instruction cache sees
400 * the return code written onto the stack.
401 */
402 flush_icache_range((unsigned long)rc,
403 (unsigned long)(rc + 2));
404
405 retcode = ((unsigned long)rc) + thumb;
406 }
407 }
408
409 regs->ARM_r0 = ksig->sig;
410 regs->ARM_sp = (unsigned long)frame;
411 regs->ARM_lr = retcode;
412 regs->ARM_pc = handler;
413 regs->ARM_cpsr = cpsr;
414
415 return 0;
416 }
417
418 static int
setup_frame(struct ksignal * ksig,sigset_t * set,struct pt_regs * regs)419 setup_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
420 {
421 struct sigframe __user *frame = get_sigframe(ksig, regs, sizeof(*frame));
422 int err = 0;
423
424 if (!frame)
425 return 1;
426
427 /*
428 * Set uc.uc_flags to a value which sc.trap_no would never have.
429 */
430 __put_user_error(0x5ac3c35a, &frame->uc.uc_flags, err);
431
432 err |= setup_sigframe(frame, regs, set);
433 if (err == 0)
434 err = setup_return(regs, ksig, frame->retcode, frame);
435
436 return err;
437 }
438
439 static int
setup_rt_frame(struct ksignal * ksig,sigset_t * set,struct pt_regs * regs)440 setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
441 {
442 struct rt_sigframe __user *frame = get_sigframe(ksig, regs, sizeof(*frame));
443 int err = 0;
444
445 if (!frame)
446 return 1;
447
448 err |= copy_siginfo_to_user(&frame->info, &ksig->info);
449
450 __put_user_error(0, &frame->sig.uc.uc_flags, err);
451 __put_user_error(NULL, &frame->sig.uc.uc_link, err);
452
453 err |= __save_altstack(&frame->sig.uc.uc_stack, regs->ARM_sp);
454 err |= setup_sigframe(&frame->sig, regs, set);
455 if (err == 0)
456 err = setup_return(regs, ksig, frame->sig.retcode, frame);
457
458 if (err == 0) {
459 /*
460 * For realtime signals we must also set the second and third
461 * arguments for the signal handler.
462 * -- Peter Maydell <pmaydell@chiark.greenend.org.uk> 2000-12-06
463 */
464 regs->ARM_r1 = (unsigned long)&frame->info;
465 regs->ARM_r2 = (unsigned long)&frame->sig.uc;
466 }
467
468 return err;
469 }
470
471 /*
472 * OK, we're invoking a handler
473 */
handle_signal(struct ksignal * ksig,struct pt_regs * regs)474 static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
475 {
476 sigset_t *oldset = sigmask_to_save();
477 int ret;
478
479 /*
480 * Set up the stack frame
481 */
482 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
483 ret = setup_rt_frame(ksig, oldset, regs);
484 else
485 ret = setup_frame(ksig, oldset, regs);
486
487 /*
488 * Check that the resulting registers are actually sane.
489 */
490 ret |= !valid_user_regs(regs);
491
492 signal_setup_done(ret, ksig, 0);
493 }
494
495 /*
496 * Note that 'init' is a special process: it doesn't get signals it doesn't
497 * want to handle. Thus you cannot kill init even with a SIGKILL even by
498 * mistake.
499 *
500 * Note that we go through the signals twice: once to check the signals that
501 * the kernel can handle, and then we build all the user-level signal handling
502 * stack-frames in one go after that.
503 */
do_signal(struct pt_regs * regs,int syscall)504 static int do_signal(struct pt_regs *regs, int syscall)
505 {
506 unsigned int retval = 0, continue_addr = 0, restart_addr = 0;
507 struct ksignal ksig;
508 int restart = 0;
509
510 /*
511 * If we were from a system call, check for system call restarting...
512 */
513 if (syscall) {
514 continue_addr = regs->ARM_pc;
515 restart_addr = continue_addr - (thumb_mode(regs) ? 2 : 4);
516 retval = regs->ARM_r0;
517
518 /*
519 * Prepare for system call restart. We do this here so that a
520 * debugger will see the already changed PSW.
521 */
522 switch (retval) {
523 case -ERESTART_RESTARTBLOCK:
524 restart -= 2;
525 case -ERESTARTNOHAND:
526 case -ERESTARTSYS:
527 case -ERESTARTNOINTR:
528 restart++;
529 regs->ARM_r0 = regs->ARM_ORIG_r0;
530 regs->ARM_pc = restart_addr;
531 break;
532 }
533 }
534
535 /*
536 * Get the signal to deliver. When running under ptrace, at this
537 * point the debugger may change all our registers ...
538 */
539 /*
540 * Depending on the signal settings we may need to revert the
541 * decision to restart the system call. But skip this if a
542 * debugger has chosen to restart at a different PC.
543 */
544 if (get_signal(&ksig)) {
545 /* handler */
546 if (unlikely(restart) && regs->ARM_pc == restart_addr) {
547 if (retval == -ERESTARTNOHAND ||
548 retval == -ERESTART_RESTARTBLOCK
549 || (retval == -ERESTARTSYS
550 && !(ksig.ka.sa.sa_flags & SA_RESTART))) {
551 regs->ARM_r0 = -EINTR;
552 regs->ARM_pc = continue_addr;
553 }
554 }
555 handle_signal(&ksig, regs);
556 } else {
557 /* no handler */
558 restore_saved_sigmask();
559 if (unlikely(restart) && regs->ARM_pc == restart_addr) {
560 regs->ARM_pc = continue_addr;
561 return restart;
562 }
563 }
564 return 0;
565 }
566
567 asmlinkage int
do_work_pending(struct pt_regs * regs,unsigned int thread_flags,int syscall)568 do_work_pending(struct pt_regs *regs, unsigned int thread_flags, int syscall)
569 {
570 do {
571 if (likely(thread_flags & _TIF_NEED_RESCHED)) {
572 schedule();
573 } else {
574 if (unlikely(!user_mode(regs)))
575 return 0;
576 local_irq_enable();
577 if (thread_flags & _TIF_SIGPENDING) {
578 int restart = do_signal(regs, syscall);
579 if (unlikely(restart)) {
580 /*
581 * Restart without handlers.
582 * Deal with it without leaving
583 * the kernel space.
584 */
585 return restart;
586 }
587 syscall = 0;
588 } else if (thread_flags & _TIF_UPROBE) {
589 uprobe_notify_resume(regs);
590 } else {
591 clear_thread_flag(TIF_NOTIFY_RESUME);
592 tracehook_notify_resume(regs);
593 }
594 }
595 local_irq_disable();
596 thread_flags = current_thread_info()->flags;
597 } while (thread_flags & _TIF_WORK_MASK);
598 return 0;
599 }
600
get_signal_page(void)601 struct page *get_signal_page(void)
602 {
603 unsigned long ptr;
604 unsigned offset;
605 struct page *page;
606 void *addr;
607
608 page = alloc_pages(GFP_KERNEL, 0);
609
610 if (!page)
611 return NULL;
612
613 addr = page_address(page);
614
615 /* Give the signal return code some randomness */
616 offset = 0x200 + (get_random_int() & 0x7fc);
617 signal_return_offset = offset;
618
619 /*
620 * Copy signal return handlers into the vector page, and
621 * set sigreturn to be a pointer to these.
622 */
623 memcpy(addr + offset, sigreturn_codes, sizeof(sigreturn_codes));
624
625 ptr = (unsigned long)addr + offset;
626 flush_icache_range(ptr, ptr + sizeof(sigreturn_codes));
627
628 return page;
629 }
630