File: /usr/src/linux/arch/s390x/kernel/signal32.c
1 /*
2 * arch/s390/kernel/signal32.c
3 *
4 * S390 version
5 * Copyright (C) 2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
6 * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
7 * Gerhard Tonn (ton@de.ibm.com)
8 *
9 * Copyright (C) 1991, 1992 Linus Torvalds
10 *
11 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
12 */
13
14 #include <linux/sched.h>
15 #include <linux/mm.h>
16 #include <linux/smp.h>
17 #include <linux/smp_lock.h>
18 #include <linux/kernel.h>
19 #include <linux/signal.h>
20 #include <linux/errno.h>
21 #include <linux/wait.h>
22 #include <linux/ptrace.h>
23 #include <linux/unistd.h>
24 #include <linux/stddef.h>
25 #include <asm/ucontext.h>
26 #include <asm/uaccess.h>
27 #include "linux32.h"
28
29 #define DEBUG_SIG 0
30
31 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
32
33 /* pretcode & sig are used to store the return addr on Intel
34 & the signal no as the first parameter we do this differently
35 using gpr14 & gpr2. */
36
37 #define SIGFRAME_COMMON32 \
38 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32]; \
39 struct sigcontext32 sc; \
40 _sigregs32 sregs; \
41 __u8 retcode[S390_SYSCALL_SIZE];
42
43 typedef struct
44 {
45 SIGFRAME_COMMON32
46 } sigframe32;
47
48 typedef struct
49 {
50 SIGFRAME_COMMON32
51 struct siginfo32 info;
52 struct ucontext32 uc;
53 } rt_sigframe32;
54
55 asmlinkage int FASTCALL(do_signal(struct pt_regs *regs, sigset_t *oldset));
56
57 int do_signal32(struct pt_regs *regs, sigset_t *oldset);
58
59 int copy_siginfo_to_user32(siginfo_t32 *to, siginfo_t *from)
60 {
61 int err;
62
63 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t32)))
64 return -EFAULT;
65
66 /* If you change siginfo_t structure, please be sure
67 this code is fixed accordingly.
68 It should never copy any pad contained in the structure
69 to avoid security leaks, but must copy the generic
70 3 ints plus the relevant union member.
71 This routine must convert siginfo from 64bit to 32bit as well
72 at the same time. */
73 err = __put_user(from->si_signo, &to->si_signo);
74 err |= __put_user(from->si_errno, &to->si_errno);
75 err |= __put_user((short)from->si_code, &to->si_code);
76 if (from->si_code < 0)
77 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
78 else {
79 switch (from->si_code >> 16) {
80 case __SI_KILL >> 16:
81 err |= __put_user(from->si_pid, &to->si_pid);
82 err |= __put_user(from->si_uid, &to->si_uid);
83 break;
84 case __SI_CHLD >> 16:
85 err |= __put_user(from->si_pid, &to->si_pid);
86 err |= __put_user(from->si_uid, &to->si_uid);
87 err |= __put_user(from->si_utime, &to->si_utime);
88 err |= __put_user(from->si_stime, &to->si_stime);
89 err |= __put_user(from->si_status, &to->si_status);
90 break;
91 case __SI_FAULT >> 16:
92 err |= __put_user(from->si_addr, &to->si_addr);
93 break;
94 case __SI_POLL >> 16:
95 case __SI_TIMER >> 16:
96 err |= __put_user(from->si_band, &to->si_band);
97 err |= __put_user(from->si_fd, &to->si_fd);
98 break;
99 default:
100 break;
101 /* case __SI_RT: This is not generated by the kernel as of now. */
102 }
103 }
104 return err;
105 }
106
107 /*
108 * Atomically swap in the new signal mask, and wait for a signal.
109 */
110 asmlinkage int
111 sys32_sigsuspend(struct pt_regs * regs,int history0, int history1, old_sigset_t mask)
112 {
113 sigset_t saveset;
114
115 mask &= _BLOCKABLE;
116 spin_lock_irq(¤t->sigmask_lock);
117 saveset = current->blocked;
118 siginitset(¤t->blocked, mask);
119 recalc_sigpending(current);
120 spin_unlock_irq(¤t->sigmask_lock);
121 regs->gprs[2] = -EINTR;
122
123 while (1) {
124 set_current_state(TASK_INTERRUPTIBLE);
125 schedule();
126 if (do_signal32(regs, &saveset))
127 return -EINTR;
128 }
129 }
130
131 asmlinkage int
132 sys32_rt_sigsuspend(struct pt_regs * regs,sigset_t32 *unewset, size_t sigsetsize)
133 {
134 sigset_t saveset, newset;
135 sigset_t32 set32;
136
137 /* XXX: Don't preclude handling different sized sigset_t's. */
138 if (sigsetsize != sizeof(sigset_t))
139 return -EINVAL;
140
141 if (copy_from_user(&set32, unewset, sizeof(set32)))
142 return -EFAULT;
143 switch (_NSIG_WORDS) {
144 case 4: newset.sig[3] = set32.sig[6] + (((long)set32.sig[7]) << 32);
145 case 3: newset.sig[2] = set32.sig[4] + (((long)set32.sig[5]) << 32);
146 case 2: newset.sig[1] = set32.sig[2] + (((long)set32.sig[3]) << 32);
147 case 1: newset.sig[0] = set32.sig[0] + (((long)set32.sig[1]) << 32);
148 }
149 sigdelsetmask(&newset, ~_BLOCKABLE);
150
151 spin_lock_irq(¤t->sigmask_lock);
152 saveset = current->blocked;
153 current->blocked = newset;
154 recalc_sigpending(current);
155 spin_unlock_irq(¤t->sigmask_lock);
156 regs->gprs[2] = -EINTR;
157
158 while (1) {
159 set_current_state(TASK_INTERRUPTIBLE);
160 schedule();
161 if (do_signal32(regs, &saveset))
162 return -EINTR;
163 }
164 }
165
166 asmlinkage int
167 sys32_sigaction(int sig, const struct old_sigaction32 *act,
168 struct old_sigaction32 *oact)
169 {
170 struct k_sigaction new_ka, old_ka;
171 int ret;
172
173 if (act) {
174 old_sigset_t32 mask;
175 if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
176 __get_user((unsigned long)new_ka.sa.sa_handler, &act->sa_handler) ||
177 __get_user((unsigned long)new_ka.sa.sa_restorer, &act->sa_restorer))
178 return -EFAULT;
179 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
180 __get_user(mask, &act->sa_mask);
181 siginitset(&new_ka.sa.sa_mask, mask);
182 }
183
184 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
185
186 if (!ret && oact) {
187 if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
188 __put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler) ||
189 __put_user((unsigned long)old_ka.sa.sa_restorer, &oact->sa_restorer))
190 return -EFAULT;
191 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
192 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
193 }
194
195 return ret;
196 }
197
198 int
199 do_sigaction(int sig, const struct k_sigaction *act, struct k_sigaction *oact);
200
201 asmlinkage long
202 sys32_rt_sigaction(int sig, const struct sigaction32 *act,
203 struct sigaction32 *oact, size_t sigsetsize)
204 {
205 struct k_sigaction new_ka, old_ka;
206 int ret;
207 sigset_t32 set32;
208
209 /* XXX: Don't preclude handling different sized sigset_t's. */
210 if (sigsetsize != sizeof(sigset_t32))
211 return -EINVAL;
212
213 if (act) {
214 ret = get_user((unsigned long)new_ka.sa.sa_handler, &act->sa_handler);
215 ret |= __copy_from_user(&set32, &act->sa_mask,
216 sizeof(sigset_t32));
217 switch (_NSIG_WORDS) {
218 case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6]
219 | (((long)set32.sig[7]) << 32);
220 case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4]
221 | (((long)set32.sig[5]) << 32);
222 case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2]
223 | (((long)set32.sig[3]) << 32);
224 case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0]
225 | (((long)set32.sig[1]) << 32);
226 }
227 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
228
229 if (ret)
230 return -EFAULT;
231 }
232
233 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
234
235 if (!ret && oact) {
236 switch (_NSIG_WORDS) {
237 case 4:
238 set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32);
239 set32.sig[6] = old_ka.sa.sa_mask.sig[3];
240 case 3:
241 set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32);
242 set32.sig[4] = old_ka.sa.sa_mask.sig[2];
243 case 2:
244 set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32);
245 set32.sig[2] = old_ka.sa.sa_mask.sig[1];
246 case 1:
247 set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32);
248 set32.sig[0] = old_ka.sa.sa_mask.sig[0];
249 }
250 ret = put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler);
251 ret |= __copy_to_user(&oact->sa_mask, &set32,
252 sizeof(sigset_t32));
253 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
254 }
255
256 return ret;
257 }
258
259 asmlinkage int
260 sys32_sigaltstack(const stack_t32 *uss, stack_t32 *uoss, struct pt_regs *regs)
261 {
262 stack_t kss, koss;
263 int ret, err = 0;
264 mm_segment_t old_fs = get_fs();
265
266 if (uss) {
267 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
268 return -EFAULT;
269 err |= __get_user(kss.ss_sp, &uss->ss_sp);
270 err |= __get_user(kss.ss_size, &uss->ss_size);
271 err |= __get_user(kss.ss_flags, &uss->ss_flags);
272 if (err)
273 return -EFAULT;
274 }
275
276 set_fs (KERNEL_DS);
277 ret = do_sigaltstack(uss ? &kss : NULL , uoss ? &koss : NULL, regs->gprs[15]);
278 set_fs (old_fs);
279
280 if (!ret && uoss) {
281 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
282 return -EFAULT;
283 err |= __put_user(koss.ss_sp, &uoss->ss_sp);
284 err |= __put_user(koss.ss_size, &uoss->ss_size);
285 err |= __put_user(koss.ss_flags, &uoss->ss_flags);
286 if (err)
287 return -EFAULT;
288 }
289 return ret;
290 }
291
292 static int save_sigregs32(struct pt_regs *regs,_sigregs32 *sregs)
293 {
294 int err = 0;
295 s390_fp_regs fpregs;
296 int i;
297
298 for(i=0; i<NUM_GPRS; i++)
299 err |= __put_user(regs->gprs[i], &sregs->regs.gprs[i]);
300 for(i=0; i<NUM_ACRS; i++)
301 err |= __put_user(regs->acrs[i], &sregs->regs.acrs[i]);
302 err |= __copy_to_user(&sregs->regs.psw.mask, ®s->psw.mask, 4);
303 err |= __copy_to_user(&sregs->regs.psw.addr, ((char*)®s->psw.addr)+4, 4);
304 if(!err)
305 {
306 save_fp_regs(&fpregs);
307 __put_user(fpregs.fpc, &sregs->fpregs.fpc);
308 for(i=0; i<NUM_FPRS; i++)
309 err |= __put_user(fpregs.fprs[i].d, &sregs->fpregs.fprs[i].d);
310 }
311 return(err);
312
313 }
314
315 static int restore_sigregs32(struct pt_regs *regs,_sigregs32 *sregs)
316 {
317 int err = 0;
318 s390_fp_regs fpregs;
319 psw_t saved_psw=regs->psw;
320 int i;
321
322 for(i=0; i<NUM_GPRS; i++)
323 err |= __get_user(regs->gprs[i], &sregs->regs.gprs[i]);
324 for(i=0; i<NUM_ACRS; i++)
325 err |= __get_user(regs->acrs[i], &sregs->regs.acrs[i]);
326 err |= __copy_from_user(®s->psw.mask, &sregs->regs.psw.mask, 4);
327 err |= __copy_from_user(((char*)®s->psw.addr)+4, &sregs->regs.psw.addr, 4);
328
329 if(!err)
330 {
331 regs->orig_gpr2 = -1; /* disable syscall checks */
332 regs->psw.mask=(saved_psw.mask&~PSW_MASK_DEBUGCHANGE)|
333 (regs->psw.mask&PSW_MASK_DEBUGCHANGE);
334 regs->psw.addr=(saved_psw.addr&~PSW_ADDR_DEBUGCHANGE)|
335 (regs->psw.addr&PSW_ADDR_DEBUGCHANGE);
336 __get_user(fpregs.fpc, &sregs->fpregs.fpc);
337 for(i=0; i<NUM_FPRS; i++)
338 err |= __get_user(fpregs.fprs[i].d, &sregs->fpregs.fprs[i].d);
339 if(!err)
340 restore_fp_regs(&fpregs);
341 }
342 return(err);
343 }
344
345 static int
346 restore_sigcontext32(struct sigcontext32 *sc, struct pt_regs *regs,
347 _sigregs32 *sregs,sigset_t *set)
348 {
349 unsigned int err;
350
351 err=restore_sigregs32(regs,sregs);
352 if(!err)
353 err=__copy_from_user(&set->sig,&sc->oldmask,_SIGMASK_COPY_SIZE32);
354 return(err);
355 }
356
357 int sigreturn_common32(struct pt_regs *regs)
358 {
359 sigframe32 *frame = (sigframe32 *)regs->gprs[15];
360 sigset_t set;
361
362 if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
363 return -1;
364 if (restore_sigcontext32(&frame->sc,regs,&frame->sregs,&set))
365 return -1;
366 sigdelsetmask(&set, ~_BLOCKABLE);
367 spin_lock_irq(¤t->sigmask_lock);
368 current->blocked = set;
369 recalc_sigpending(current);
370 spin_unlock_irq(¤t->sigmask_lock);
371 return 0;
372 }
373
374 asmlinkage long sys32_sigreturn(struct pt_regs *regs)
375 {
376
377 if (sigreturn_common32(regs))
378 goto badframe;
379 return regs->gprs[2];
380
381 badframe:
382 force_sig(SIGSEGV, current);
383 return 0;
384 }
385
386 asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
387 {
388 rt_sigframe32 *frame = (rt_sigframe32 *)regs->gprs[15];
389 stack_t st;
390 int err;
391 mm_segment_t old_fs = get_fs();
392
393 if (sigreturn_common32(regs))
394 goto badframe;
395
396 err = __get_user(st.ss_sp, &frame->uc.uc_stack.ss_sp);
397 st.ss_sp = (void *) A((unsigned long)st.ss_sp);
398 err |= __get_user(st.ss_size, &frame->uc.uc_stack.ss_size);
399 err |= __get_user(st.ss_flags, &frame->uc.uc_stack.ss_flags);
400 if (err)
401 goto badframe;
402 set_fs (KERNEL_DS);
403 /* It is more difficult to avoid calling this function than to
404 call it and ignore errors. */
405 do_sigaltstack(&st, NULL, regs->gprs[15]);
406 set_fs (old_fs);
407
408 return regs->gprs[2];
409
410 badframe:
411 force_sig(SIGSEGV, current);
412 return 0;
413 }
414
415 /*
416 * Set up a signal frame.
417 */
418
419
420 /*
421 * Determine which stack to use..
422 */
423 static inline void *
424 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
425 {
426 unsigned long sp;
427
428 /* Default to using normal stack */
429 sp = (unsigned long) A(regs->gprs[15]);
430
431 /* This is the X/Open sanctioned signal stack switching. */
432 if (ka->sa.sa_flags & SA_ONSTACK) {
433 if (! on_sig_stack(sp))
434 sp = current->sas_ss_sp + current->sas_ss_size;
435 }
436
437 /* This is the legacy signal stack switching. */
438 else if (!user_mode(regs) &&
439 !(ka->sa.sa_flags & SA_RESTORER) &&
440 ka->sa.sa_restorer) {
441 sp = (unsigned long) ka->sa.sa_restorer;
442 }
443
444 return (void *)((sp - frame_size) & -8ul);
445 }
446
447 static void *setup_frame_common32(int sig, struct k_sigaction *ka,
448 sigset_t *set, struct pt_regs * regs,
449 int frame_size,u16 retcode)
450 {
451 sigframe32 *frame;
452 int err;
453
454 frame = get_sigframe(ka, regs,frame_size);
455 if (!access_ok(VERIFY_WRITE, frame,frame_size))
456 return 0;
457 err = save_sigregs32(regs,&frame->sregs);
458 if(!err)
459 err=__put_user(&frame->sregs,&frame->sc.sregs);
460 if(!err)
461
462 err=__copy_to_user(&frame->sc.oldmask,&set->sig,_SIGMASK_COPY_SIZE32);
463 if(!err)
464 {
465 regs->gprs[2]=(current->exec_domain
466 && current->exec_domain->signal_invmap
467 && sig < 32
468 ? current->exec_domain->signal_invmap[sig]
469 : sig);
470 /* Set up registers for signal handler */
471 regs->gprs[15] = (addr_t)frame;
472 regs->psw.addr = FIX_PSW(ka->sa.sa_handler);
473 }
474 /* Set up to return from userspace. If provided, use a stub
475 already in userspace. */
476 if (ka->sa.sa_flags & SA_RESTORER) {
477 regs->gprs[14] = FIX_PSW(ka->sa.sa_restorer);
478 } else {
479 regs->gprs[14] = FIX_PSW(frame->retcode);
480 err |= __put_user(retcode, (u16 *)(frame->retcode));
481 }
482 return(err ? 0:frame);
483 }
484
485 static void setup_frame32(int sig, struct k_sigaction *ka,
486 sigset_t *set, struct pt_regs * regs)
487 {
488 sigframe32 *frame;
489
490 if((frame=setup_frame_common32(sig,ka,set,regs,sizeof(sigframe32),
491 (S390_SYSCALL_OPCODE|__NR_sigreturn)))==0)
492 goto give_sigsegv;
493 #if DEBUG_SIG
494 printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
495 current->comm, current->pid, frame, regs->eip, frame->pretcode);
496 #endif
497 /* Martin wants this for pthreads */
498 regs->gprs[3] = (addr_t)&frame->sc;
499 return;
500
501 give_sigsegv:
502 if (sig == SIGSEGV)
503 ka->sa.sa_handler = SIG_DFL;
504 force_sig(SIGSEGV, current);
505 }
506
507 static void setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info,
508 sigset_t *set, struct pt_regs * regs)
509 {
510 rt_sigframe32 *frame;
511 addr_t orig_sp=regs->gprs[15];
512 int err;
513
514 if((frame=setup_frame_common32(sig,ka,set,regs,sizeof(rt_sigframe32),
515 (S390_SYSCALL_OPCODE|__NR_rt_sigreturn)))==0)
516 goto give_sigsegv;
517
518 err = copy_siginfo_to_user32(&frame->info, info);
519
520 /* Create the ucontext. */
521 err |= __put_user(0, &frame->uc.uc_flags);
522 err |= __put_user(0, &frame->uc.uc_link);
523 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
524 err |= __put_user(sas_ss_flags(orig_sp),
525 &frame->uc.uc_stack.ss_flags);
526 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
527 regs->gprs[3] = (addr_t)&frame->info;
528 regs->gprs[4] = (addr_t)&frame->uc;
529
530 if (err)
531 goto give_sigsegv;
532
533 #if DEBUG_SIG
534 printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
535 current->comm, current->pid, frame, regs->eip, frame->pretcode);
536 #endif
537 return;
538
539 give_sigsegv:
540 if (sig == SIGSEGV)
541 ka->sa.sa_handler = SIG_DFL;
542 force_sig(SIGSEGV, current);
543 }
544
545 /*
546 * OK, we're invoking a handler
547 */
548
549 static void
550 handle_signal32(unsigned long sig, struct k_sigaction *ka,
551 siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
552 {
553 /* Are we from a system call? */
554 if (regs->orig_gpr2 >= 0) {
555 /* If so, check system call restarting.. */
556 switch (regs->gprs[2]) {
557 case -ERESTARTNOHAND:
558 regs->gprs[2] = -EINTR;
559 break;
560
561 case -ERESTARTSYS:
562 if (!(ka->sa.sa_flags & SA_RESTART)) {
563 regs->gprs[2] = -EINTR;
564 break;
565 }
566 /* fallthrough */
567 case -ERESTARTNOINTR:
568 regs->gprs[2] = regs->orig_gpr2;
569 regs->psw.addr -= 2;
570 }
571 }
572
573 /* Set up the stack frame */
574 if (ka->sa.sa_flags & SA_SIGINFO)
575 setup_rt_frame32(sig, ka, info, oldset, regs);
576 else
577 setup_frame32(sig, ka, oldset, regs);
578
579 if (ka->sa.sa_flags & SA_ONESHOT)
580 ka->sa.sa_handler = SIG_DFL;
581
582 if (!(ka->sa.sa_flags & SA_NODEFER)) {
583 spin_lock_irq(¤t->sigmask_lock);
584 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
585 sigaddset(¤t->blocked,sig);
586 recalc_sigpending(current);
587 spin_unlock_irq(¤t->sigmask_lock);
588 }
589 }
590
591 /*
592 * Note that 'init' is a special process: it doesn't get signals it doesn't
593 * want to handle. Thus you cannot kill init even with a SIGKILL even by
594 * mistake.
595 *
596 * Note that we go through the signals twice: once to check the signals that
597 * the kernel can handle, and then we build all the user-level signal handling
598 * stack-frames in one go after that.
599 */
600 int do_signal32(struct pt_regs *regs, sigset_t *oldset)
601 {
602 siginfo_t info;
603 struct k_sigaction *ka;
604
605 /*
606 * We want the common case to go fast, which
607 * is why we may in certain cases get here from
608 * kernel mode. Just return without doing anything
609 * if so.
610 */
611 if (!user_mode(regs))
612 return 1;
613
614 if (!oldset)
615 oldset = ¤t->blocked;
616
617 for (;;) {
618 unsigned long signr;
619
620 spin_lock_irq(¤t->sigmask_lock);
621 signr = dequeue_signal(¤t->blocked, &info);
622 spin_unlock_irq(¤t->sigmask_lock);
623
624 if (!signr)
625 break;
626
627 if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
628 /* Let the debugger run. */
629 current->exit_code = signr;
630 set_current_state(TASK_STOPPED);
631 notify_parent(current, SIGCHLD);
632 schedule();
633
634 /* We're back. Did the debugger cancel the sig? */
635 if (!(signr = current->exit_code))
636 continue;
637 current->exit_code = 0;
638
639 /* The debugger continued. Ignore SIGSTOP. */
640 if (signr == SIGSTOP)
641 continue;
642
643 /* Update the siginfo structure. Is this good? */
644 if (signr != info.si_signo) {
645 info.si_signo = signr;
646 info.si_errno = 0;
647 info.si_code = SI_USER;
648 info.si_pid = current->p_pptr->pid;
649 info.si_uid = current->p_pptr->uid;
650 }
651
652 /* If the (new) signal is now blocked, requeue it. */
653 if (sigismember(¤t->blocked, signr)) {
654 send_sig_info(signr, &info, current);
655 continue;
656 }
657 }
658
659 ka = ¤t->sig->action[signr-1];
660 if (ka->sa.sa_handler == SIG_IGN) {
661 if (signr != SIGCHLD)
662 continue;
663 /* Check for SIGCHLD: it's special. */
664 while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
665 /* nothing */;
666 continue;
667 }
668
669 if (ka->sa.sa_handler == SIG_DFL) {
670 int exit_code = signr;
671
672 /* Init gets no signals it doesn't want. */
673 if (current->pid == 1)
674 continue;
675
676 switch (signr) {
677 case SIGCONT: case SIGCHLD: case SIGWINCH:
678 continue;
679
680 case SIGTSTP: case SIGTTIN: case SIGTTOU:
681 if (is_orphaned_pgrp(current->pgrp))
682 continue;
683 /* FALLTHRU */
684
685 case SIGSTOP:
686 set_current_state(TASK_STOPPED);
687 current->exit_code = signr;
688 if (!(current->p_pptr->sig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
689 notify_parent(current, SIGCHLD);
690 schedule();
691 continue;
692
693 case SIGQUIT: case SIGILL: case SIGTRAP:
694 case SIGABRT: case SIGFPE: case SIGSEGV:
695 if (do_coredump(signr, regs))
696 exit_code |= 0x80;
697 /* FALLTHRU */
698
699 default:
700 lock_kernel();
701 sigaddset(¤t->pending.signal, signr);
702 recalc_sigpending(current);
703 current->flags |= PF_SIGNALED;
704 do_exit(exit_code);
705 /* NOTREACHED */
706 }
707 }
708
709 /* Whee! Actually deliver the signal. */
710 handle_signal32(signr, ka, &info, oldset, regs);
711 return 1;
712 }
713
714 /* Did we come from a system call? */
715 if ( regs->trap == __LC_SVC_OLD_PSW /* System Call! */ ) {
716 /* Restart the system call - no handlers present */
717 if (regs->gprs[2] == -ERESTARTNOHAND ||
718 regs->gprs[2] == -ERESTARTSYS ||
719 regs->gprs[2] == -ERESTARTNOINTR) {
720 regs->gprs[2] = regs->orig_gpr2;
721 regs->psw.addr -= 2;
722 }
723 }
724 return 0;
725 }
726