1
2
3
4
5
6
7
8
9
10#include <linux/errno.h>
11#include <linux/signal.h>
12#include <linux/personality.h>
13#include <linux/freezer.h>
14#include <linux/uaccess.h>
15#include <linux/tracehook.h>
16
17#include <asm/elf.h>
18#include <asm/cacheflush.h>
19#include <asm/ucontext.h>
20#include <asm/unistd.h>
21
22#include "ptrace.h"
23#include "signal.h"
24
25#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
26
27
28
29
30#define SWI_SYS_SIGRETURN (0xef000000|(__NR_sigreturn)|(__NR_OABI_SYSCALL_BASE))
31#define SWI_SYS_RT_SIGRETURN (0xef000000|(__NR_rt_sigreturn)|(__NR_OABI_SYSCALL_BASE))
32#define SWI_SYS_RESTART (0xef000000|__NR_restart_syscall|__NR_OABI_SYSCALL_BASE)
33
34
35
36
37#define MOV_R7_NR_SIGRETURN (0xe3a07000 | (__NR_sigreturn - __NR_SYSCALL_BASE))
38#define MOV_R7_NR_RT_SIGRETURN (0xe3a07000 | (__NR_rt_sigreturn - __NR_SYSCALL_BASE))
39
40
41
42
43
44#define SWI_THUMB_SIGRETURN (0xdf00 << 16 | 0x2700 | (__NR_sigreturn - __NR_SYSCALL_BASE))
45#define SWI_THUMB_RT_SIGRETURN (0xdf00 << 16 | 0x2700 | (__NR_rt_sigreturn - __NR_SYSCALL_BASE))
46
47const unsigned long sigreturn_codes[7] = {
48 MOV_R7_NR_SIGRETURN, SWI_SYS_SIGRETURN, SWI_THUMB_SIGRETURN,
49 MOV_R7_NR_RT_SIGRETURN, SWI_SYS_RT_SIGRETURN, SWI_THUMB_RT_SIGRETURN,
50};
51
52
53
54
55
56
57
58
59const unsigned long syscall_restart_code[2] = {
60 SWI_SYS_RESTART,
61 0xe49df004,
62};
63
64
65
66
67asmlinkage int sys_sigsuspend(int restart, unsigned long oldmask, old_sigset_t mask)
68{
69 mask &= _BLOCKABLE;
70 spin_lock_irq(¤t->sighand->siglock);
71 current->saved_sigmask = current->blocked;
72 siginitset(¤t->blocked, mask);
73 recalc_sigpending();
74 spin_unlock_irq(¤t->sighand->siglock);
75
76 current->state = TASK_INTERRUPTIBLE;
77 schedule();
78 set_restore_sigmask();
79 return -ERESTARTNOHAND;
80}
81
82asmlinkage int
83sys_sigaction(int sig, const struct old_sigaction __user *act,
84 struct old_sigaction __user *oact)
85{
86 struct k_sigaction new_ka, old_ka;
87 int ret;
88
89 if (act) {
90 old_sigset_t mask;
91 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
92 __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
93 __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
94 return -EFAULT;
95 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
96 __get_user(mask, &act->sa_mask);
97 siginitset(&new_ka.sa.sa_mask, mask);
98 }
99
100 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
101
102 if (!ret && oact) {
103 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
104 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
105 __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
106 return -EFAULT;
107 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
108 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
109 }
110
111 return ret;
112}
113
114#ifdef CONFIG_CRUNCH
115static int preserve_crunch_context(struct crunch_sigframe __user *frame)
116{
117 char kbuf[sizeof(*frame) + 8];
118 struct crunch_sigframe *kframe;
119
120
121 kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7);
122 kframe->magic = CRUNCH_MAGIC;
123 kframe->size = CRUNCH_STORAGE_SIZE;
124 crunch_task_copy(current_thread_info(), &kframe->storage);
125 return __copy_to_user(frame, kframe, sizeof(*frame));
126}
127
128static int restore_crunch_context(struct crunch_sigframe __user *frame)
129{
130 char kbuf[sizeof(*frame) + 8];
131 struct crunch_sigframe *kframe;
132
133
134 kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7);
135 if (__copy_from_user(kframe, frame, sizeof(*frame)))
136 return -1;
137 if (kframe->magic != CRUNCH_MAGIC ||
138 kframe->size != CRUNCH_STORAGE_SIZE)
139 return -1;
140 crunch_task_restore(current_thread_info(), &kframe->storage);
141 return 0;
142}
143#endif
144
145#ifdef CONFIG_IWMMXT
146
147static int preserve_iwmmxt_context(struct iwmmxt_sigframe *frame)
148{
149 char kbuf[sizeof(*frame) + 8];
150 struct iwmmxt_sigframe *kframe;
151
152
153 kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7);
154 kframe->magic = IWMMXT_MAGIC;
155 kframe->size = IWMMXT_STORAGE_SIZE;
156 iwmmxt_task_copy(current_thread_info(), &kframe->storage);
157 return __copy_to_user(frame, kframe, sizeof(*frame));
158}
159
160static int restore_iwmmxt_context(struct iwmmxt_sigframe *frame)
161{
162 char kbuf[sizeof(*frame) + 8];
163 struct iwmmxt_sigframe *kframe;
164
165
166 kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7);
167 if (__copy_from_user(kframe, frame, sizeof(*frame)))
168 return -1;
169 if (kframe->magic != IWMMXT_MAGIC ||
170 kframe->size != IWMMXT_STORAGE_SIZE)
171 return -1;
172 iwmmxt_task_restore(current_thread_info(), &kframe->storage);
173 return 0;
174}
175
176#endif
177
178
179
180
181struct sigframe {
182 struct ucontext uc;
183 unsigned long retcode[2];
184};
185
186struct rt_sigframe {
187 struct siginfo info;
188 struct sigframe sig;
189};
190
191static int restore_sigframe(struct pt_regs *regs, struct sigframe __user *sf)
192{
193 struct aux_sigframe __user *aux;
194 sigset_t set;
195 int err;
196
197 err = __copy_from_user(&set, &sf->uc.uc_sigmask, sizeof(set));
198 if (err == 0) {
199 sigdelsetmask(&set, ~_BLOCKABLE);
200 spin_lock_irq(¤t->sighand->siglock);
201 current->blocked = set;
202 recalc_sigpending();
203 spin_unlock_irq(¤t->sighand->siglock);
204 }
205
206 __get_user_error(regs->ARM_r0, &sf->uc.uc_mcontext.arm_r0, err);
207 __get_user_error(regs->ARM_r1, &sf->uc.uc_mcontext.arm_r1, err);
208 __get_user_error(regs->ARM_r2, &sf->uc.uc_mcontext.arm_r2, err);
209 __get_user_error(regs->ARM_r3, &sf->uc.uc_mcontext.arm_r3, err);
210 __get_user_error(regs->ARM_r4, &sf->uc.uc_mcontext.arm_r4, err);
211 __get_user_error(regs->ARM_r5, &sf->uc.uc_mcontext.arm_r5, err);
212 __get_user_error(regs->ARM_r6, &sf->uc.uc_mcontext.arm_r6, err);
213 __get_user_error(regs->ARM_r7, &sf->uc.uc_mcontext.arm_r7, err);
214 __get_user_error(regs->ARM_r8, &sf->uc.uc_mcontext.arm_r8, err);
215 __get_user_error(regs->ARM_r9, &sf->uc.uc_mcontext.arm_r9, err);
216 __get_user_error(regs->ARM_r10, &sf->uc.uc_mcontext.arm_r10, err);
217 __get_user_error(regs->ARM_fp, &sf->uc.uc_mcontext.arm_fp, err);
218 __get_user_error(regs->ARM_ip, &sf->uc.uc_mcontext.arm_ip, err);
219 __get_user_error(regs->ARM_sp, &sf->uc.uc_mcontext.arm_sp, err);
220 __get_user_error(regs->ARM_lr, &sf->uc.uc_mcontext.arm_lr, err);
221 __get_user_error(regs->ARM_pc, &sf->uc.uc_mcontext.arm_pc, err);
222 __get_user_error(regs->ARM_cpsr, &sf->uc.uc_mcontext.arm_cpsr, err);
223
224 err |= !valid_user_regs(regs);
225
226 aux = (struct aux_sigframe __user *) sf->uc.uc_regspace;
227#ifdef CONFIG_CRUNCH
228 if (err == 0)
229 err |= restore_crunch_context(&aux->crunch);
230#endif
231#ifdef CONFIG_IWMMXT
232 if (err == 0 && test_thread_flag(TIF_USING_IWMMXT))
233 err |= restore_iwmmxt_context(&aux->iwmmxt);
234#endif
235#ifdef CONFIG_VFP
236
237
238#endif
239
240 return err;
241}
242
243asmlinkage int sys_sigreturn(struct pt_regs *regs)
244{
245 struct sigframe __user *frame;
246
247
248 current_thread_info()->restart_block.fn = do_no_restart_syscall;
249
250
251
252
253
254
255 if (regs->ARM_sp & 7)
256 goto badframe;
257
258 frame = (struct sigframe __user *)regs->ARM_sp;
259
260 if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
261 goto badframe;
262
263 if (restore_sigframe(regs, frame))
264 goto badframe;
265
266 single_step_trap(current);
267
268 return regs->ARM_r0;
269
270badframe:
271 force_sig(SIGSEGV, current);
272 return 0;
273}
274
275asmlinkage int sys_rt_sigreturn(struct pt_regs *regs)
276{
277 struct rt_sigframe __user *frame;
278
279
280 current_thread_info()->restart_block.fn = do_no_restart_syscall;
281
282
283
284
285
286
287 if (regs->ARM_sp & 7)
288 goto badframe;
289
290 frame = (struct rt_sigframe __user *)regs->ARM_sp;
291
292 if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
293 goto badframe;
294
295 if (restore_sigframe(regs, &frame->sig))
296 goto badframe;
297
298 if (do_sigaltstack(&frame->sig.uc.uc_stack, NULL, regs->ARM_sp) == -EFAULT)
299 goto badframe;
300
301 single_step_trap(current);
302
303 return regs->ARM_r0;
304
305badframe:
306 force_sig(SIGSEGV, current);
307 return 0;
308}
309
310static int
311setup_sigframe(struct sigframe __user *sf, struct pt_regs *regs, sigset_t *set)
312{
313 struct aux_sigframe __user *aux;
314 int err = 0;
315
316 __put_user_error(regs->ARM_r0, &sf->uc.uc_mcontext.arm_r0, err);
317 __put_user_error(regs->ARM_r1, &sf->uc.uc_mcontext.arm_r1, err);
318 __put_user_error(regs->ARM_r2, &sf->uc.uc_mcontext.arm_r2, err);
319 __put_user_error(regs->ARM_r3, &sf->uc.uc_mcontext.arm_r3, err);
320 __put_user_error(regs->ARM_r4, &sf->uc.uc_mcontext.arm_r4, err);
321 __put_user_error(regs->ARM_r5, &sf->uc.uc_mcontext.arm_r5, err);
322 __put_user_error(regs->ARM_r6, &sf->uc.uc_mcontext.arm_r6, err);
323 __put_user_error(regs->ARM_r7, &sf->uc.uc_mcontext.arm_r7, err);
324 __put_user_error(regs->ARM_r8, &sf->uc.uc_mcontext.arm_r8, err);
325 __put_user_error(regs->ARM_r9, &sf->uc.uc_mcontext.arm_r9, err);
326 __put_user_error(regs->ARM_r10, &sf->uc.uc_mcontext.arm_r10, err);
327 __put_user_error(regs->ARM_fp, &sf->uc.uc_mcontext.arm_fp, err);
328 __put_user_error(regs->ARM_ip, &sf->uc.uc_mcontext.arm_ip, err);
329 __put_user_error(regs->ARM_sp, &sf->uc.uc_mcontext.arm_sp, err);
330 __put_user_error(regs->ARM_lr, &sf->uc.uc_mcontext.arm_lr, err);
331 __put_user_error(regs->ARM_pc, &sf->uc.uc_mcontext.arm_pc, err);
332 __put_user_error(regs->ARM_cpsr, &sf->uc.uc_mcontext.arm_cpsr, err);
333
334 __put_user_error(current->thread.trap_no, &sf->uc.uc_mcontext.trap_no, err);
335 __put_user_error(current->thread.error_code, &sf->uc.uc_mcontext.error_code, err);
336 __put_user_error(current->thread.address, &sf->uc.uc_mcontext.fault_address, err);
337 __put_user_error(set->sig[0], &sf->uc.uc_mcontext.oldmask, err);
338
339 err |= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(*set));
340
341 aux = (struct aux_sigframe __user *) sf->uc.uc_regspace;
342#ifdef CONFIG_CRUNCH
343 if (err == 0)
344 err |= preserve_crunch_context(&aux->crunch);
345#endif
346#ifdef CONFIG_IWMMXT
347 if (err == 0 && test_thread_flag(TIF_USING_IWMMXT))
348 err |= preserve_iwmmxt_context(&aux->iwmmxt);
349#endif
350#ifdef CONFIG_VFP
351
352
353#endif
354 __put_user_error(0, &aux->end_magic, err);
355
356 return err;
357}
358
359static inline void __user *
360get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, int framesize)
361{
362 unsigned long sp = regs->ARM_sp;
363 void __user *frame;
364
365
366
367
368 if ((ka->sa.sa_flags & SA_ONSTACK) && !sas_ss_flags(sp))
369 sp = current->sas_ss_sp + current->sas_ss_size;
370
371
372
373
374 frame = (void __user *)((sp - framesize) & ~7);
375
376
377
378
379 if (!access_ok(VERIFY_WRITE, frame, framesize))
380 frame = NULL;
381
382 return frame;
383}
384
385static int
386setup_return(struct pt_regs *regs, struct k_sigaction *ka,
387 unsigned long __user *rc, void __user *frame, int usig)
388{
389 unsigned long handler = (unsigned long)ka->sa.sa_handler;
390 unsigned long retcode;
391 int thumb = 0;
392 unsigned long cpsr = regs->ARM_cpsr & ~PSR_f;
393
394
395
396
397 if (ka->sa.sa_flags & SA_THIRTYTWO)
398 cpsr = (cpsr & ~MODE_MASK) | USR_MODE;
399
400#ifdef CONFIG_ARM_THUMB
401 if (elf_hwcap & HWCAP_THUMB) {
402
403
404
405
406 thumb = handler & 1;
407
408 if (thumb) {
409 cpsr |= PSR_T_BIT;
410#if __LINUX_ARM_ARCH__ >= 7
411
412 cpsr &= ~PSR_IT_MASK;
413#endif
414 } else
415 cpsr &= ~PSR_T_BIT;
416 }
417#endif
418
419 if (ka->sa.sa_flags & SA_RESTORER) {
420 retcode = (unsigned long)ka->sa.sa_restorer;
421 } else {
422 unsigned int idx = thumb << 1;
423
424 if (ka->sa.sa_flags & SA_SIGINFO)
425 idx += 3;
426
427 if (__put_user(sigreturn_codes[idx], rc) ||
428 __put_user(sigreturn_codes[idx+1], rc+1))
429 return 1;
430
431 if (cpsr & MODE32_BIT) {
432
433
434
435
436 retcode = KERN_SIGRETURN_CODE + (idx << 2) + thumb;
437 } else {
438
439
440
441
442 flush_icache_range((unsigned long)rc,
443 (unsigned long)(rc + 2));
444
445 retcode = ((unsigned long)rc) + thumb;
446 }
447 }
448
449 regs->ARM_r0 = usig;
450 regs->ARM_sp = (unsigned long)frame;
451 regs->ARM_lr = retcode;
452 regs->ARM_pc = handler;
453 regs->ARM_cpsr = cpsr;
454
455 return 0;
456}
457
458static int
459setup_frame(int usig, struct k_sigaction *ka, sigset_t *set, struct pt_regs *regs)
460{
461 struct sigframe __user *frame = get_sigframe(ka, regs, sizeof(*frame));
462 int err = 0;
463
464 if (!frame)
465 return 1;
466
467
468
469
470 __put_user_error(0x5ac3c35a, &frame->uc.uc_flags, err);
471
472 err |= setup_sigframe(frame, regs, set);
473 if (err == 0)
474 err = setup_return(regs, ka, frame->retcode, frame, usig);
475
476 return err;
477}
478
479static int
480setup_rt_frame(int usig, struct k_sigaction *ka, siginfo_t *info,
481 sigset_t *set, struct pt_regs *regs)
482{
483 struct rt_sigframe __user *frame = get_sigframe(ka, regs, sizeof(*frame));
484 stack_t stack;
485 int err = 0;
486
487 if (!frame)
488 return 1;
489
490 err |= copy_siginfo_to_user(&frame->info, info);
491
492 __put_user_error(0, &frame->sig.uc.uc_flags, err);
493 __put_user_error(NULL, &frame->sig.uc.uc_link, err);
494
495 memset(&stack, 0, sizeof(stack));
496 stack.ss_sp = (void __user *)current->sas_ss_sp;
497 stack.ss_flags = sas_ss_flags(regs->ARM_sp);
498 stack.ss_size = current->sas_ss_size;
499 err |= __copy_to_user(&frame->sig.uc.uc_stack, &stack, sizeof(stack));
500
501 err |= setup_sigframe(&frame->sig, regs, set);
502 if (err == 0)
503 err = setup_return(regs, ka, frame->sig.retcode, frame, usig);
504
505 if (err == 0) {
506
507
508
509
510
511 regs->ARM_r1 = (unsigned long)&frame->info;
512 regs->ARM_r2 = (unsigned long)&frame->sig.uc;
513 }
514
515 return err;
516}
517
518static inline void setup_syscall_restart(struct pt_regs *regs)
519{
520 regs->ARM_r0 = regs->ARM_ORIG_r0;
521 regs->ARM_pc -= thumb_mode(regs) ? 2 : 4;
522}
523
524
525
526
527static int
528handle_signal(unsigned long sig, struct k_sigaction *ka,
529 siginfo_t *info, sigset_t *oldset,
530 struct pt_regs * regs, int syscall)
531{
532 struct thread_info *thread = current_thread_info();
533 struct task_struct *tsk = current;
534 int usig = sig;
535 int ret;
536
537
538
539
540 if (syscall) {
541 switch (regs->ARM_r0) {
542 case -ERESTART_RESTARTBLOCK:
543 case -ERESTARTNOHAND:
544 regs->ARM_r0 = -EINTR;
545 break;
546 case -ERESTARTSYS:
547 if (!(ka->sa.sa_flags & SA_RESTART)) {
548 regs->ARM_r0 = -EINTR;
549 break;
550 }
551
552 case -ERESTARTNOINTR:
553 setup_syscall_restart(regs);
554 }
555 }
556
557
558
559
560 if (usig < 32 && thread->exec_domain && thread->exec_domain->signal_invmap)
561 usig = thread->exec_domain->signal_invmap[usig];
562
563
564
565
566 if (ka->sa.sa_flags & SA_SIGINFO)
567 ret = setup_rt_frame(usig, ka, info, oldset, regs);
568 else
569 ret = setup_frame(usig, ka, oldset, regs);
570
571
572
573
574 ret |= !valid_user_regs(regs);
575
576 if (ret != 0) {
577 force_sigsegv(sig, tsk);
578 return ret;
579 }
580
581
582
583
584 spin_lock_irq(&tsk->sighand->siglock);
585 sigorsets(&tsk->blocked, &tsk->blocked,
586 &ka->sa.sa_mask);
587 if (!(ka->sa.sa_flags & SA_NODEFER))
588 sigaddset(&tsk->blocked, sig);
589 recalc_sigpending();
590 spin_unlock_irq(&tsk->sighand->siglock);
591
592 return 0;
593}
594
595
596
597
598
599
600
601
602
603
604static void do_signal(struct pt_regs *regs, int syscall)
605{
606 struct k_sigaction ka;
607 siginfo_t info;
608 int signr;
609
610
611
612
613
614
615
616 if (!user_mode(regs))
617 return;
618
619 if (try_to_freeze())
620 goto no_signal;
621
622 single_step_clear(current);
623
624 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
625 if (signr > 0) {
626 sigset_t *oldset;
627
628 if (test_thread_flag(TIF_RESTORE_SIGMASK))
629 oldset = ¤t->saved_sigmask;
630 else
631 oldset = ¤t->blocked;
632 if (handle_signal(signr, &ka, &info, oldset, regs, syscall) == 0) {
633
634
635
636
637
638
639 if (test_thread_flag(TIF_RESTORE_SIGMASK))
640 clear_thread_flag(TIF_RESTORE_SIGMASK);
641 }
642 single_step_set(current);
643 return;
644 }
645
646 no_signal:
647
648
649
650 if (syscall) {
651 if (regs->ARM_r0 == -ERESTART_RESTARTBLOCK) {
652 if (thumb_mode(regs)) {
653 regs->ARM_r7 = __NR_restart_syscall - __NR_SYSCALL_BASE;
654 regs->ARM_pc -= 2;
655 } else {
656#if defined(CONFIG_AEABI) && !defined(CONFIG_OABI_COMPAT)
657 regs->ARM_r7 = __NR_restart_syscall;
658 regs->ARM_pc -= 4;
659#else
660 u32 __user *usp;
661
662 regs->ARM_sp -= 4;
663 usp = (u32 __user *)regs->ARM_sp;
664
665 if (put_user(regs->ARM_pc, usp) == 0) {
666 regs->ARM_pc = KERN_RESTART_CODE;
667 } else {
668 regs->ARM_sp += 4;
669 force_sigsegv(0, current);
670 }
671#endif
672 }
673 }
674 if (regs->ARM_r0 == -ERESTARTNOHAND ||
675 regs->ARM_r0 == -ERESTARTSYS ||
676 regs->ARM_r0 == -ERESTARTNOINTR) {
677 setup_syscall_restart(regs);
678 }
679
680
681
682
683 if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
684 clear_thread_flag(TIF_RESTORE_SIGMASK);
685 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL);
686 }
687 }
688 single_step_set(current);
689}
690
691asmlinkage void
692do_notify_resume(struct pt_regs *regs, unsigned int thread_flags, int syscall)
693{
694 if (thread_flags & _TIF_SIGPENDING)
695 do_signal(regs, syscall);
696
697 if (thread_flags & _TIF_NOTIFY_RESUME) {
698 clear_thread_flag(TIF_NOTIFY_RESUME);
699 tracehook_notify_resume(regs);
700 if (current->replacement_session_keyring)
701 key_replace_session_keyring();
702 }
703}
704