1
2
3
4
5#include <linux/sched.h>
6#include <linux/mm.h>
7#include <linux/kernel.h>
8#include <linux/signal.h>
9#include <linux/errno.h>
10#include <linux/wait.h>
11#include <linux/ptrace.h>
12#include <linux/unistd.h>
13#include <linux/stddef.h>
14#include <linux/syscalls.h>
15#include <linux/vmalloc.h>
16
17#include <asm/io.h>
18#include <asm/processor.h>
19#include <asm/ucontext.h>
20#include <asm/uaccess.h>
21#include <arch/ptrace.h>
22#include <arch/hwregs/cpu_vect.h>
23
24extern unsigned long cris_signal_return_page;
25
26
27#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
28
29
30
31
32
33
34
35
36#define RESTART_CRIS_SYS(regs) regs->r10 = regs->orig_r10; regs->erp -= 2;
37
38
39struct signal_frame {
40 struct sigcontext sc;
41 unsigned long extramask[_NSIG_WORDS - 1];
42 unsigned char retcode[8];
43};
44
45struct rt_signal_frame {
46 struct siginfo *pinfo;
47 void *puc;
48 struct siginfo info;
49 struct ucontext uc;
50 unsigned char retcode[8];
51};
52
53void do_signal(int restart, struct pt_regs *regs);
54void keep_debug_flags(unsigned long oldccs, unsigned long oldspc,
55 struct pt_regs *regs);
56
57
58
59
60int
61sys_sigsuspend(old_sigset_t mask, long r11, long r12, long r13, long mof,
62 long srp, struct pt_regs *regs)
63{
64 mask &= _BLOCKABLE;
65 spin_lock_irq(¤t->sighand->siglock);
66 current->saved_sigmask = current->blocked;
67 siginitset(¤t->blocked, mask);
68 recalc_sigpending();
69 spin_unlock_irq(¤t->sighand->siglock);
70 current->state = TASK_INTERRUPTIBLE;
71 schedule();
72 set_thread_flag(TIF_RESTORE_SIGMASK);
73 return -ERESTARTNOHAND;
74}
75
76int
77sys_sigaction(int signal, const struct old_sigaction *act,
78 struct old_sigaction *oact)
79{
80 int retval;
81 struct k_sigaction newk;
82 struct k_sigaction oldk;
83
84 if (act) {
85 old_sigset_t mask;
86
87 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
88 __get_user(newk.sa.sa_handler, &act->sa_handler) ||
89 __get_user(newk.sa.sa_restorer, &act->sa_restorer))
90 return -EFAULT;
91
92 __get_user(newk.sa.sa_flags, &act->sa_flags);
93 __get_user(mask, &act->sa_mask);
94 siginitset(&newk.sa.sa_mask, mask);
95 }
96
97 retval = do_sigaction(signal, act ? &newk : NULL, oact ? &oldk : NULL);
98
99 if (!retval && oact) {
100 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
101 __put_user(oldk.sa.sa_handler, &oact->sa_handler) ||
102 __put_user(oldk.sa.sa_restorer, &oact->sa_restorer))
103 return -EFAULT;
104
105 __put_user(oldk.sa.sa_flags, &oact->sa_flags);
106 __put_user(oldk.sa.sa_mask.sig[0], &oact->sa_mask);
107 }
108
109 return retval;
110}
111
112int
113sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss)
114{
115 return do_sigaltstack(uss, uoss, rdusp());
116}
117
118static int
119restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
120{
121 unsigned int err = 0;
122 unsigned long old_usp;
123
124
125 current_thread_info()->restart_block.fn = do_no_restart_syscall;
126
127
128
129
130
131
132 if (__copy_from_user(regs, sc, sizeof(struct pt_regs)))
133 goto badframe;
134
135
136 regs->ccs |= (1 << (U_CCS_BITNR + CCS_SHIFT));
137
138
139 err |= __get_user(old_usp, &sc->usp);
140 wrusp(old_usp);
141
142 return err;
143
144badframe:
145 return 1;
146}
147
148
149asmlinkage int
150sys_sigreturn(long r10, long r11, long r12, long r13, long mof, long srp,
151 struct pt_regs *regs)
152{
153 sigset_t set;
154 struct signal_frame __user *frame;
155 unsigned long oldspc = regs->spc;
156 unsigned long oldccs = regs->ccs;
157
158 frame = (struct signal_frame *) rdusp();
159
160
161
162
163
164
165 if (((long)frame) & 3)
166 goto badframe;
167
168 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
169 goto badframe;
170
171 if (__get_user(set.sig[0], &frame->sc.oldmask) ||
172 (_NSIG_WORDS > 1 && __copy_from_user(&set.sig[1],
173 frame->extramask,
174 sizeof(frame->extramask))))
175 goto badframe;
176
177 sigdelsetmask(&set, ~_BLOCKABLE);
178 spin_lock_irq(¤t->sighand->siglock);
179
180 current->blocked = set;
181
182 recalc_sigpending();
183 spin_unlock_irq(¤t->sighand->siglock);
184
185 if (restore_sigcontext(regs, &frame->sc))
186 goto badframe;
187
188 keep_debug_flags(oldccs, oldspc, regs);
189
190 return regs->r10;
191
192badframe:
193 force_sig(SIGSEGV, current);
194 return 0;
195}
196
197
198asmlinkage int
199sys_rt_sigreturn(long r10, long r11, long r12, long r13, long mof, long srp,
200 struct pt_regs *regs)
201{
202 sigset_t set;
203 struct rt_signal_frame __user *frame;
204 unsigned long oldspc = regs->spc;
205 unsigned long oldccs = regs->ccs;
206
207 frame = (struct rt_signal_frame *) rdusp();
208
209
210
211
212
213
214 if (((long)frame) & 3)
215 goto badframe;
216
217 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
218 goto badframe;
219
220 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
221 goto badframe;
222
223 sigdelsetmask(&set, ~_BLOCKABLE);
224 spin_lock_irq(¤t->sighand->siglock);
225
226 current->blocked = set;
227
228 recalc_sigpending();
229 spin_unlock_irq(¤t->sighand->siglock);
230
231 if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
232 goto badframe;
233
234 if (do_sigaltstack(&frame->uc.uc_stack, NULL, rdusp()) == -EFAULT)
235 goto badframe;
236
237 keep_debug_flags(oldccs, oldspc, regs);
238
239 return regs->r10;
240
241badframe:
242 force_sig(SIGSEGV, current);
243 return 0;
244}
245
246
247static int
248setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
249 unsigned long mask)
250{
251 int err;
252 unsigned long usp;
253
254 err = 0;
255 usp = rdusp();
256
257
258
259
260
261 err |= __copy_to_user(sc, regs, sizeof(struct pt_regs));
262
263 err |= __put_user(mask, &sc->oldmask);
264 err |= __put_user(usp, &sc->usp);
265
266 return err;
267}
268
269
270static inline void __user *
271get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
272{
273 unsigned long sp;
274
275 sp = rdusp();
276
277
278 if (ka->sa.sa_flags & SA_ONSTACK) {
279 if (!on_sig_stack(sp))
280 sp = current->sas_ss_sp + current->sas_ss_size;
281 }
282
283
284 sp &= ~3;
285
286 return (void __user *)(sp - frame_size);
287}
288
289
290
291
292
293
294
295
296static int
297setup_frame(int sig, struct k_sigaction *ka, sigset_t *set,
298 struct pt_regs * regs)
299{
300 int err;
301 unsigned long return_ip;
302 struct signal_frame __user *frame;
303
304 err = 0;
305 frame = get_sigframe(ka, regs, sizeof(*frame));
306
307 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
308 goto give_sigsegv;
309
310 err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
311
312 if (err)
313 goto give_sigsegv;
314
315 if (_NSIG_WORDS > 1) {
316 err |= __copy_to_user(frame->extramask, &set->sig[1],
317 sizeof(frame->extramask));
318 }
319
320 if (err)
321 goto give_sigsegv;
322
323
324
325
326
327 if (ka->sa.sa_flags & SA_RESTORER) {
328 return_ip = (unsigned long)ka->sa.sa_restorer;
329 } else {
330
331 return_ip = cris_signal_return_page;
332
333
334
335
336
337
338
339
340 err |= __put_user(0x9c5f, (short __user*)(frame->retcode+0));
341 err |= __put_user(__NR_sigreturn, (short __user*)(frame->retcode+2));
342 err |= __put_user(0xe93d, (short __user*)(frame->retcode+4));
343 }
344
345 if (err)
346 goto give_sigsegv;
347
348
349
350
351
352
353
354
355 regs->erp = (unsigned long) ka->sa.sa_handler;
356 regs->srp = return_ip;
357 regs->r10 = sig;
358
359
360 wrusp((unsigned long)frame);
361
362 return 0;
363
364give_sigsegv:
365 if (sig == SIGSEGV)
366 ka->sa.sa_handler = SIG_DFL;
367
368 force_sig(SIGSEGV, current);
369 return -EFAULT;
370}
371
372static int
373setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
374 sigset_t *set, struct pt_regs * regs)
375{
376 int err;
377 unsigned long return_ip;
378 struct rt_signal_frame __user *frame;
379
380 err = 0;
381 frame = get_sigframe(ka, regs, sizeof(*frame));
382
383 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
384 goto give_sigsegv;
385
386
387
388 err |= __put_user(&frame->info, &frame->pinfo);
389 err |= __put_user(&frame->uc, &frame->puc);
390 err |= copy_siginfo_to_user(&frame->info, info);
391
392 if (err)
393 goto give_sigsegv;
394
395
396 err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext));
397 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, set->sig[0]);
398 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
399
400 if (err)
401 goto give_sigsegv;
402
403
404
405
406
407 if (ka->sa.sa_flags & SA_RESTORER) {
408 return_ip = (unsigned long) ka->sa.sa_restorer;
409 } else {
410
411 return_ip = cris_signal_return_page + 6;
412
413
414
415
416
417
418
419
420 err |= __put_user(0x9c5f, (short __user*)(frame->retcode+0));
421
422 err |= __put_user(__NR_rt_sigreturn,
423 (short __user*)(frame->retcode+2));
424
425 err |= __put_user(0xe93d, (short __user*)(frame->retcode+4));
426 }
427
428 if (err)
429 goto give_sigsegv;
430
431
432
433
434
435
436
437
438
439
440 regs->erp = (unsigned long) ka->sa.sa_handler;
441 regs->srp = return_ip;
442 regs->r10 = sig;
443 regs->r11 = (unsigned long) &frame->info;
444 regs->r12 = 0;
445
446
447 wrusp((unsigned long)frame);
448
449 return 0;
450
451give_sigsegv:
452 if (sig == SIGSEGV)
453 ka->sa.sa_handler = SIG_DFL;
454
455 force_sig(SIGSEGV, current);
456 return -EFAULT;
457}
458
459
460static inline int
461handle_signal(int canrestart, unsigned long sig,
462 siginfo_t *info, struct k_sigaction *ka,
463 sigset_t *oldset, struct pt_regs * regs)
464{
465 int ret;
466
467
468 if (canrestart) {
469
470 switch (regs->r10) {
471 case -ERESTART_RESTARTBLOCK:
472 case -ERESTARTNOHAND:
473
474
475
476
477
478
479
480
481 regs->r10 = -EINTR;
482 break;
483
484 case -ERESTARTSYS:
485
486
487
488
489
490 if (!(ka->sa.sa_flags & SA_RESTART)) {
491 regs->r10 = -EINTR;
492 break;
493 }
494
495
496
497 case -ERESTARTNOINTR:
498
499
500
501
502
503 RESTART_CRIS_SYS(regs);
504 break;
505 }
506 }
507
508
509 if (ka->sa.sa_flags & SA_SIGINFO)
510 ret = setup_rt_frame(sig, ka, info, oldset, regs);
511 else
512 ret = setup_frame(sig, ka, oldset, regs);
513
514 if (ka->sa.sa_flags & SA_ONESHOT)
515 ka->sa.sa_handler = SIG_DFL;
516
517 if (ret == 0) {
518 spin_lock_irq(¤t->sighand->siglock);
519 sigorsets(¤t->blocked, ¤t->blocked,
520 &ka->sa.sa_mask);
521 if (!(ka->sa.sa_flags & SA_NODEFER))
522 sigaddset(¤t->blocked, sig);
523 recalc_sigpending();
524 spin_unlock_irq(¤t->sighand->siglock);
525 }
526
527 return ret;
528}
529
530
531
532
533
534
535
536
537
538
539
540
541void
542do_signal(int canrestart, struct pt_regs *regs)
543{
544 int signr;
545 siginfo_t info;
546 struct k_sigaction ka;
547 sigset_t *oldset;
548
549
550
551
552
553
554 if (!user_mode(regs))
555 return;
556
557 if (test_thread_flag(TIF_RESTORE_SIGMASK))
558 oldset = ¤t->saved_sigmask;
559 else
560 oldset = ¤t->blocked;
561
562 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
563
564 if (signr > 0) {
565
566 if (handle_signal(canrestart, signr, &info, &ka,
567 oldset, regs)) {
568
569
570
571
572 if (test_thread_flag(TIF_RESTORE_SIGMASK))
573 clear_thread_flag(TIF_RESTORE_SIGMASK);
574 }
575
576 return;
577 }
578
579
580 if (canrestart) {
581
582 if (regs->r10 == -ERESTARTNOHAND ||
583 regs->r10 == -ERESTARTSYS ||
584 regs->r10 == -ERESTARTNOINTR) {
585 RESTART_CRIS_SYS(regs);
586 }
587
588 if (regs->r10 == -ERESTART_RESTARTBLOCK){
589 regs->r10 = __NR_restart_syscall;
590 regs->erp -= 2;
591 }
592 }
593
594
595
596 if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
597 clear_thread_flag(TIF_RESTORE_SIGMASK);
598 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL);
599 }
600}
601
602asmlinkage void
603ugdb_trap_user(struct thread_info *ti, int sig)
604{
605 if (((user_regs(ti)->exs & 0xff00) >> 8) != SINGLE_STEP_INTR_VECT) {
606
607
608
609 user_regs(ti)->spc = 0;
610 }
611
612
613
614 if (((user_regs(ti)->exs & 0xff00) >> 8) == BREAK_8_INTR_VECT) {
615
616 if (!(user_regs(ti)->erp & 0x1))
617 user_regs(ti)->erp -= 2;
618 }
619 sys_kill(ti->task->pid, sig);
620}
621
622void
623keep_debug_flags(unsigned long oldccs, unsigned long oldspc,
624 struct pt_regs *regs)
625{
626 if (oldccs & (1 << Q_CCS_BITNR)) {
627
628
629 regs->ccs |= (1 << Q_CCS_BITNR);
630
631 if (!(oldccs & (1 << (S_CCS_BITNR + CCS_SHIFT)))) {
632 printk("Q flag but no S flag?");
633 }
634 regs->ccs |= (1 << (S_CCS_BITNR + CCS_SHIFT));
635
636 regs->spc = oldspc;
637
638 } else if (oldccs & (1 << (S_CCS_BITNR + CCS_SHIFT))) {
639
640
641 regs->ccs |= (1 << (S_CCS_BITNR + CCS_SHIFT));
642
643
644 } else if (regs->spc) {
645
646
647
648 regs->spc = 0;
649 regs->ccs &= ~(1 << (S_CCS_BITNR + CCS_SHIFT));
650 }
651}
652
653
654int __init
655cris_init_signal(void)
656{
657 u16* data = kmalloc(PAGE_SIZE, GFP_KERNEL);
658
659
660 data[0] = 0x9c5f;
661 data[1] = __NR_sigreturn;
662 data[2] = 0xe93d;
663
664 data[3] = 0x9c5f;
665 data[4] = __NR_rt_sigreturn;
666 data[5] = 0xe93d;
667
668
669 cris_signal_return_page = (unsigned long)
670 __ioremap_prot(virt_to_phys(data), PAGE_SIZE, PAGE_SIGNAL_TRAMPOLINE);
671
672 return 0;
673}
674
675__initcall(cris_init_signal);
676