File: /usr/src/linux/arch/mips/kernel/signal.c
1 /*
2 * This file is subject to the terms and conditions of the GNU General Public
3 * License. See the file "COPYING" in the main directory of this archive
4 * for more details.
5 *
6 * Copyright (C) 1991, 1992 Linus Torvalds
7 * Copyright (C) 1994 - 1999 Ralf Baechle
8 * Copyright (C) 1999 Silicon Graphics, Inc.
9 */
10 #include <linux/config.h>
11 #include <linux/sched.h>
12 #include <linux/mm.h>
13 #include <linux/smp.h>
14 #include <linux/smp_lock.h>
15 #include <linux/kernel.h>
16 #include <linux/signal.h>
17 #include <linux/errno.h>
18 #include <linux/wait.h>
19 #include <linux/ptrace.h>
20 #include <linux/unistd.h>
21
22 #include <asm/asm.h>
23 #include <asm/bitops.h>
24 #include <asm/pgalloc.h>
25 #include <asm/stackframe.h>
26 #include <asm/uaccess.h>
27 #include <asm/ucontext.h>
28
29 #define DEBUG_SIG 0
30
31 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
32
33 extern asmlinkage int do_signal(sigset_t *oldset, struct pt_regs *regs);
34
35 extern asmlinkage int (*save_fp_context)(struct sigcontext *sc);
36 extern asmlinkage int (*restore_fp_context)(struct sigcontext *sc);
37
38 extern asmlinkage void syscall_trace(void);
39
40 int copy_siginfo_to_user(siginfo_t *to, siginfo_t *from)
41 {
42 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
43 return -EFAULT;
44 if (from->si_code < 0)
45 return __copy_to_user(to, from, sizeof(siginfo_t));
46 else {
47 int err;
48
49 /* If you change siginfo_t structure, please be sure
50 this code is fixed accordingly.
51 It should never copy any pad contained in the structure
52 to avoid security leaks, but must copy the generic
53 3 ints plus the relevant union member. */
54 err = __put_user(from->si_signo, &to->si_signo);
55 err |= __put_user(from->si_errno, &to->si_errno);
56 err |= __put_user((short)from->si_code, &to->si_code);
57 /* First 32bits of unions are always present. */
58 err |= __put_user(from->si_pid, &to->si_pid);
59 switch (from->si_code >> 16) {
60 case __SI_FAULT >> 16:
61 break;
62 case __SI_CHLD >> 16:
63 err |= __put_user(from->si_utime, &to->si_utime);
64 err |= __put_user(from->si_stime, &to->si_stime);
65 err |= __put_user(from->si_status, &to->si_status);
66 default:
67 err |= __put_user(from->si_uid, &to->si_uid);
68 break;
69 /* case __SI_RT: This is not generated by the kernel as of now. */
70 }
71 return err;
72 }
73 }
74
75 /*
76 * Atomically swap in the new signal mask, and wait for a signal.
77 */
78 save_static_function(sys_sigsuspend);
79 static_unused int
80 _sys_sigsuspend(struct pt_regs regs)
81 {
82 sigset_t *uset, saveset, newset;
83
84 uset = (sigset_t *) regs.regs[4];
85 if (copy_from_user(&newset, uset, sizeof(sigset_t)))
86 return -EFAULT;
87 sigdelsetmask(&newset, ~_BLOCKABLE);
88
89 spin_lock_irq(¤t->sigmask_lock);
90 saveset = current->blocked;
91 current->blocked = newset;
92 recalc_sigpending(current);
93 spin_unlock_irq(¤t->sigmask_lock);
94
95 regs.regs[2] = EINTR;
96 regs.regs[7] = 1;
97 while (1) {
98 current->state = TASK_INTERRUPTIBLE;
99 schedule();
100 if (do_signal(&saveset, ®s))
101 return -EINTR;
102 }
103 }
104
105
106 save_static_function(sys_rt_sigsuspend);
107 static_unused int
108 _sys_rt_sigsuspend(struct pt_regs regs)
109 {
110 sigset_t *unewset, saveset, newset;
111 size_t sigsetsize;
112
113 /* XXX Don't preclude handling different sized sigset_t's. */
114 sigsetsize = regs.regs[5];
115 if (sigsetsize != sizeof(sigset_t))
116 return -EINVAL;
117
118 unewset = (sigset_t *) regs.regs[4];
119 if (copy_from_user(&newset, unewset, sizeof(newset)))
120 return -EFAULT;
121 sigdelsetmask(&newset, ~_BLOCKABLE);
122
123 spin_lock_irq(¤t->sigmask_lock);
124 saveset = current->blocked;
125 current->blocked = newset;
126 recalc_sigpending(current);
127 spin_unlock_irq(¤t->sigmask_lock);
128
129 regs.regs[2] = EINTR;
130 regs.regs[7] = 1;
131 while (1) {
132 current->state = TASK_INTERRUPTIBLE;
133 schedule();
134 if (do_signal(&saveset, ®s))
135 return -EINTR;
136 }
137 }
138
139 asmlinkage int
140 sys_sigaction(int sig, const struct sigaction *act, struct sigaction *oact)
141 {
142 struct k_sigaction new_ka, old_ka;
143 int ret;
144 int err = 0;
145
146 if (act) {
147 old_sigset_t mask;
148
149 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
150 return -EFAULT;
151 err |= __get_user(new_ka.sa.sa_handler, &act->sa_handler);
152 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
153 err |= __get_user(mask, &act->sa_mask.sig[0]);
154 err |= __get_user(new_ka.sa.sa_restorer, &act->sa_restorer);
155 if (err)
156 return -EFAULT;
157
158 siginitset(&new_ka.sa.sa_mask, mask);
159 }
160
161 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
162
163 if (!ret && oact) {
164 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
165 return -EFAULT;
166 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
167 err |= __put_user(old_ka.sa.sa_handler, &oact->sa_handler);
168 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
169 err |= __put_user(0, &oact->sa_mask.sig[1]);
170 err |= __put_user(0, &oact->sa_mask.sig[2]);
171 err |= __put_user(0, &oact->sa_mask.sig[3]);
172 err |= __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer);
173 if (err)
174 return -EFAULT;
175 }
176
177 return ret;
178 }
179
180 asmlinkage int
181 sys_sigaltstack(struct pt_regs regs)
182 {
183 const stack_t *uss = (const stack_t *) regs.regs[4];
184 stack_t *uoss = (stack_t *) regs.regs[5];
185 unsigned long usp = regs.regs[29];
186
187 return do_sigaltstack(uss, uoss, usp);
188 }
189
190 asmlinkage int
191 restore_sigcontext(struct pt_regs *regs, struct sigcontext *sc)
192 {
193 int owned_fp;
194 int err = 0;
195 u64 reg;
196
197 err |= __get_user(regs->cp0_epc, &sc->sc_pc);
198
199 err |= __get_user(reg, &sc->sc_mdhi);
200 regs->hi = (int) reg;
201 err |= __get_user(reg, &sc->sc_mdlo);
202 regs->lo = (int) reg;
203
204 #define restore_gp_reg(i) do { \
205 err |= __get_user(reg, &sc->sc_regs[i]); \
206 regs->regs[i] = reg; \
207 } while(0);
208 restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
209 restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
210 restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
211 restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
212 restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
213 restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
214 restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
215 restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
216 restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
217 restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
218 restore_gp_reg(31);
219 #undef restore_gp_reg
220
221 err |= __get_user(owned_fp, &sc->sc_ownedfp);
222 if (owned_fp) {
223 err |= restore_fp_context(sc);
224 last_task_used_math = current;
225 }
226
227 return err;
228 }
229
230 struct sigframe {
231 u32 sf_ass[4]; /* argument save space for o32 */
232 u32 sf_code[2]; /* signal trampoline */
233 struct sigcontext sf_sc;
234 sigset_t sf_mask;
235 };
236
237 struct rt_sigframe {
238 u32 rs_ass[4]; /* argument save space for o32 */
239 u32 rs_code[2]; /* signal trampoline */
240 struct siginfo rs_info;
241 struct ucontext rs_uc;
242 };
243
244 asmlinkage void
245 sys_sigreturn(struct pt_regs regs)
246 {
247 struct sigframe *frame;
248 sigset_t blocked;
249
250 frame = (struct sigframe *) regs.regs[29];
251 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
252 goto badframe;
253 if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked)))
254 goto badframe;
255
256 sigdelsetmask(&blocked, ~_BLOCKABLE);
257 spin_lock_irq(¤t->sigmask_lock);
258 current->blocked = blocked;
259 recalc_sigpending(current);
260 spin_unlock_irq(¤t->sigmask_lock);
261
262 if (restore_sigcontext(®s, &frame->sf_sc))
263 goto badframe;
264
265 /*
266 * Don't let your children do this ...
267 */
268 if (current->ptrace & PT_TRACESYS)
269 syscall_trace();
270 __asm__ __volatile__(
271 "move\t$29, %0\n\t"
272 "j\tret_from_sys_call"
273 :/* no outputs */
274 :"r" (®s));
275 /* Unreached */
276
277 badframe:
278 force_sig(SIGSEGV, current);
279 }
280
281 asmlinkage void
282 sys_rt_sigreturn(struct pt_regs regs)
283 {
284 struct rt_sigframe *frame;
285 sigset_t set;
286 stack_t st;
287
288 frame = (struct rt_sigframe *) regs.regs[29];
289 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
290 goto badframe;
291 if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
292 goto badframe;
293
294 sigdelsetmask(&set, ~_BLOCKABLE);
295 spin_lock_irq(¤t->sigmask_lock);
296 current->blocked = set;
297 recalc_sigpending(current);
298 spin_unlock_irq(¤t->sigmask_lock);
299
300 if (restore_sigcontext(®s, &frame->rs_uc.uc_mcontext))
301 goto badframe;
302
303 if (__copy_from_user(&st, &frame->rs_uc.uc_stack, sizeof(st)))
304 goto badframe;
305 /* It is more difficult to avoid calling this function than to
306 call it and ignore errors. */
307 do_sigaltstack(&st, NULL, regs.regs[29]);
308
309 /*
310 * Don't let your children do this ...
311 */
312 __asm__ __volatile__(
313 "move\t$29, %0\n\t"
314 "j\tret_from_sys_call"
315 :/* no outputs */
316 :"r" (®s));
317 /* Unreached */
318
319 badframe:
320 force_sig(SIGSEGV, current);
321 }
322
323 static int inline
324 setup_sigcontext(struct pt_regs *regs, struct sigcontext *sc)
325 {
326 int owned_fp;
327 int err = 0;
328 u64 reg;
329
330 err |= __put_user(regs->cp0_epc, &sc->sc_pc);
331 err |= __put_user(regs->cp0_status, &sc->sc_status);
332
333 #define save_gp_reg(i) { \
334 reg = regs->regs[i]; \
335 err |= __put_user(reg, &sc->sc_regs[i]); \
336 } while(0)
337 __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2);
338 save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
339 save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
340 save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
341 save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
342 save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
343 save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
344 save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
345 save_gp_reg(31);
346 #undef save_gp_reg
347
348 err |= __put_user(regs->hi, &sc->sc_mdhi);
349 err |= __put_user(regs->lo, &sc->sc_mdlo);
350 err |= __put_user(regs->cp0_cause, &sc->sc_cause);
351 err |= __put_user(regs->cp0_badvaddr, &sc->sc_badvaddr);
352
353 owned_fp = (current == last_task_used_math);
354 err |= __put_user(owned_fp, &sc->sc_ownedfp);
355
356 if (current->used_math) { /* fp is active. */
357 set_cp0_status(ST0_CU1);
358 err |= save_fp_context(sc);
359 last_task_used_math = NULL;
360 regs->cp0_status &= ~ST0_CU1;
361 current->used_math = 0;
362 }
363
364 return err;
365 }
366
367 /*
368 * Determine which stack to use..
369 */
370 static inline void *
371 get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size)
372 {
373 unsigned long sp;
374
375 /* Default to using normal stack */
376 sp = regs->regs[29];
377
378 /* This is the X/Open sanctioned signal stack switching. */
379 if ((ka->sa.sa_flags & SA_ONSTACK) && ! on_sig_stack(sp))
380 sp = current->sas_ss_sp + current->sas_ss_size;
381
382 return (void *)((sp - frame_size) & ALMASK);
383 }
384
385 static void inline
386 setup_frame(struct k_sigaction * ka, struct pt_regs *regs,
387 int signr, sigset_t *set)
388 {
389 struct sigframe *frame;
390 int err = 0;
391
392 frame = get_sigframe(ka, regs, sizeof(*frame));
393 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
394 goto give_sigsegv;
395
396 /* Set up to return from userspace. If provided, use a stub already
397 in userspace. */
398 if (ka->sa.sa_flags & SA_RESTORER)
399 regs->regs[31] = (unsigned long) ka->sa.sa_restorer;
400 else {
401 /*
402 * Set up the return code ...
403 *
404 * li v0, __NR_sigreturn
405 * syscall
406 */
407 err |= __put_user(0x24020000 + __NR_sigreturn,
408 frame->sf_code + 0);
409 err |= __put_user(0x0000000c ,
410 frame->sf_code + 1);
411 flush_cache_sigtramp((unsigned long) frame->sf_code);
412 }
413
414 err |= setup_sigcontext(regs, &frame->sf_sc);
415 err |= __copy_to_user(&frame->sf_mask, set, sizeof(*set));
416 if (err)
417 goto give_sigsegv;
418
419 /*
420 * Arguments to signal handler:
421 *
422 * a0 = signal number
423 * a1 = 0 (should be cause)
424 * a2 = pointer to struct sigcontext
425 *
426 * $25 and c0_epc point to the signal handler, $29 points to the
427 * struct sigframe.
428 */
429 regs->regs[ 4] = signr;
430 regs->regs[ 5] = 0;
431 regs->regs[ 6] = (unsigned long) &frame->sf_sc;
432 regs->regs[29] = (unsigned long) frame;
433 regs->regs[31] = (unsigned long) frame->sf_code;
434 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
435
436 #if DEBUG_SIG
437 printk("SIG deliver (%s:%d): sp=0x%p pc=0x%p ra=0x%p\n",
438 current->comm, current->pid, frame, regs->cp0_epc, frame->code);
439 #endif
440 return;
441
442 give_sigsegv:
443 if (signr == SIGSEGV)
444 ka->sa.sa_handler = SIG_DFL;
445 force_sig(SIGSEGV, current);
446 }
447
448 static void inline
449 setup_rt_frame(struct k_sigaction * ka, struct pt_regs *regs,
450 int signr, sigset_t *set, siginfo_t *info)
451 {
452 struct rt_sigframe *frame;
453 int err = 0;
454
455 frame = get_sigframe(ka, regs, sizeof(*frame));
456 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
457 goto give_sigsegv;
458
459 /* Set up to return from userspace. If provided, use a stub already
460 in userspace. */
461 if (ka->sa.sa_flags & SA_RESTORER)
462 regs->regs[31] = (unsigned long) ka->sa.sa_restorer;
463 else {
464 /*
465 * Set up the return code ...
466 *
467 * li v0, __NR_rt_sigreturn
468 * syscall
469 */
470 err |= __put_user(0x24020000 + __NR_rt_sigreturn,
471 frame->rs_code + 0);
472 err |= __put_user(0x0000000c ,
473 frame->rs_code + 1);
474 flush_cache_sigtramp((unsigned long) frame->rs_code);
475 }
476
477 /* Create siginfo. */
478 err |= copy_siginfo_to_user(&frame->rs_info, info);
479
480 /* Create the ucontext. */
481 err |= __put_user(0, &frame->rs_uc.uc_flags);
482 err |= __put_user(0, &frame->rs_uc.uc_link);
483 err |= __put_user((void *)current->sas_ss_sp,
484 &frame->rs_uc.uc_stack.ss_sp);
485 err |= __put_user(sas_ss_flags(regs->regs[29]),
486 &frame->rs_uc.uc_stack.ss_flags);
487 err |= __put_user(current->sas_ss_size,
488 &frame->rs_uc.uc_stack.ss_size);
489 err |= setup_sigcontext(regs, &frame->rs_uc.uc_mcontext);
490 err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set));
491
492 if (err)
493 goto give_sigsegv;
494
495 /*
496 * Arguments to signal handler:
497 *
498 * a0 = signal number
499 * a1 = 0 (should be cause)
500 * a2 = pointer to ucontext
501 *
502 * $25 and c0_epc point to the signal handler, $29 points to
503 * the struct rt_sigframe.
504 */
505 regs->regs[ 4] = signr;
506 regs->regs[ 5] = (unsigned long) &frame->rs_info;
507 regs->regs[ 6] = (unsigned long) &frame->rs_uc;
508 regs->regs[29] = (unsigned long) frame;
509 regs->regs[31] = (unsigned long) frame->rs_code;
510 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
511
512 #if DEBUG_SIG
513 printk("SIG deliver (%s:%d): sp=0x%p pc=0x%p ra=0x%p\n",
514 current->comm, current->pid, frame, regs->cp0_epc, frame->code);
515 #endif
516 return;
517
518 give_sigsegv:
519 if (signr == SIGSEGV)
520 ka->sa.sa_handler = SIG_DFL;
521 force_sig(SIGSEGV, current);
522 }
523
524 static inline void
525 handle_signal(unsigned long sig, struct k_sigaction *ka,
526 siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
527 {
528 if (ka->sa.sa_flags & SA_SIGINFO)
529 setup_rt_frame(ka, regs, sig, oldset, info);
530 else
531 setup_frame(ka, regs, sig, oldset);
532
533 if (ka->sa.sa_flags & SA_ONESHOT)
534 ka->sa.sa_handler = SIG_DFL;
535 if (!(ka->sa.sa_flags & SA_NODEFER)) {
536 spin_lock_irq(¤t->sigmask_lock);
537 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
538 sigaddset(¤t->blocked,sig);
539 recalc_sigpending(current);
540 spin_unlock_irq(¤t->sigmask_lock);
541 }
542 }
543
544 static inline void
545 syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
546 {
547 switch(regs->regs[0]) {
548 case ERESTARTNOHAND:
549 regs->regs[2] = EINTR;
550 break;
551 case ERESTARTSYS:
552 if(!(ka->sa.sa_flags & SA_RESTART)) {
553 regs->regs[2] = EINTR;
554 break;
555 }
556 /* fallthrough */
557 case ERESTARTNOINTR: /* Userland will reload $v0. */
558 regs->regs[7] = regs->regs[26];
559 regs->cp0_epc -= 8;
560 }
561
562 regs->regs[0] = 0; /* Don't deal with this again. */
563 }
564
565 extern int do_irix_signal(sigset_t *oldset, struct pt_regs *regs);
566
567 asmlinkage int do_signal(sigset_t *oldset, struct pt_regs *regs)
568 {
569 struct k_sigaction *ka;
570 siginfo_t info;
571
572 #ifdef CONFIG_BINFMT_IRIX
573 if (current->personality != PER_LINUX)
574 return do_irix_signal(oldset, regs);
575 #endif
576
577 if (!oldset)
578 oldset = ¤t->blocked;
579
580 for (;;) {
581 unsigned long signr;
582
583 spin_lock_irq(¤t->sigmask_lock);
584 signr = dequeue_signal(¤t->blocked, &info);
585 spin_unlock_irq(¤t->sigmask_lock);
586
587 if (!signr)
588 break;
589
590 if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
591 /* Let the debugger run. */
592 current->exit_code = signr;
593 current->state = TASK_STOPPED;
594 notify_parent(current, SIGCHLD);
595 schedule();
596
597 /* We're back. Did the debugger cancel the sig? */
598 if (!(signr = current->exit_code))
599 continue;
600 current->exit_code = 0;
601
602 /* The debugger continued. Ignore SIGSTOP. */
603 if (signr == SIGSTOP)
604 continue;
605
606 /* Update the siginfo structure. Is this good? */
607 if (signr != info.si_signo) {
608 info.si_signo = signr;
609 info.si_errno = 0;
610 info.si_code = SI_USER;
611 info.si_pid = current->p_pptr->pid;
612 info.si_uid = current->p_pptr->uid;
613 }
614
615 /* If the (new) signal is now blocked, requeue it. */
616 if (sigismember(¤t->blocked, signr)) {
617 send_sig_info(signr, &info, current);
618 continue;
619 }
620 }
621
622 ka = ¤t->sig->action[signr-1];
623 if (ka->sa.sa_handler == SIG_IGN) {
624 if (signr != SIGCHLD)
625 continue;
626 /* Check for SIGCHLD: it's special. */
627 while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
628 /* nothing */;
629 continue;
630 }
631
632 if (ka->sa.sa_handler == SIG_DFL) {
633 int exit_code = signr;
634
635 /* Init gets no signals it doesn't want. */
636 if (current->pid == 1)
637 continue;
638
639 switch (signr) {
640 case SIGCONT: case SIGCHLD: case SIGWINCH:
641 continue;
642
643 case SIGTSTP: case SIGTTIN: case SIGTTOU:
644 if (is_orphaned_pgrp(current->pgrp))
645 continue;
646 /* FALLTHRU */
647
648 case SIGSTOP:
649 current->state = TASK_STOPPED;
650 current->exit_code = signr;
651 if (!(current->p_pptr->sig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
652 notify_parent(current, SIGCHLD);
653 schedule();
654 continue;
655
656 case SIGQUIT: case SIGILL: case SIGTRAP:
657 case SIGABRT: case SIGFPE: case SIGSEGV:
658 case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ:
659 if (do_coredump(signr, regs))
660 exit_code |= 0x80;
661 /* FALLTHRU */
662
663 default:
664 sigaddset(¤t->pending.signal, signr);
665 recalc_sigpending(current);
666 current->flags |= PF_SIGNALED;
667 do_exit(exit_code);
668 /* NOTREACHED */
669 }
670 }
671
672 if (regs->regs[0])
673 syscall_restart(regs, ka);
674 /* Whee! Actually deliver the signal. */
675 handle_signal(signr, ka, &info, oldset, regs);
676 return 1;
677 }
678
679 /*
680 * Who's code doesn't conform to the restartable syscall convention
681 * dies here!!! The li instruction, a single machine instruction,
682 * must directly be followed by the syscall instruction.
683 */
684 if (regs->regs[0]) {
685 if (regs->regs[2] == ERESTARTNOHAND ||
686 regs->regs[2] == ERESTARTSYS ||
687 regs->regs[2] == ERESTARTNOINTR) {
688 regs->regs[7] = regs->regs[26];
689 regs->cp0_epc -= 8;
690 }
691 }
692 return 0;
693 }
694