1 /* $Id: signal.c,v 1.60 2002/02/09 19:49:31 davem Exp $
2 * arch/sparc64/kernel/signal.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
6 * Copyright (C) 1996 Miguel de Icaza (miguel@nuclecu.unam.mx)
7 * Copyright (C) 1997 Eddie C. Dost (ecd@skynet.be)
8 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
11 #include <linux/config.h>
12 #ifdef CONFIG_SPARC32_COMPAT
13 #include <linux/compat.h> /* for compat_old_sigset_t */
15 #include <linux/sched.h>
16 #include <linux/kernel.h>
17 #include <linux/signal.h>
18 #include <linux/errno.h>
19 #include <linux/wait.h>
20 #include <linux/ptrace.h>
21 #include <linux/unistd.h>
23 #include <linux/tty.h>
24 #include <linux/smp_lock.h>
25 #include <linux/binfmts.h>
27 #include <asm/uaccess.h>
28 #include <asm/bitops.h>
29 #include <asm/ptrace.h>
31 #include <asm/pgtable.h>
32 #include <asm/fpumacro.h>
34 #include <asm/siginfo.h>
35 #include <asm/visasm.h>
37 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
39 static int do_signal(sigset_t *oldset, struct pt_regs * regs,
40 unsigned long orig_o0, int ret_from_syscall);
42 /* {set, get}context() needed for 64-bit SparcLinux userland. */
43 asmlinkage void sparc64_set_context(struct pt_regs *regs)
45 struct ucontext *ucp = (struct ucontext __user *) regs->u_regs[UREG_I0];
46 mc_gregset_t __user *grp;
47 unsigned long pc, npc, tstate;
53 if (get_thread_wsaved() ||
54 (((unsigned long)ucp) & (sizeof(unsigned long)-1)) ||
55 (!__access_ok((unsigned long)ucp, sizeof(*ucp))))
57 grp = &ucp->uc_mcontext.mc_gregs;
58 err = __get_user(pc, &((*grp)[MC_PC]));
59 err |= __get_user(npc, &((*grp)[MC_NPC]));
60 if (err || ((pc | npc) & 3))
62 if (regs->u_regs[UREG_I1]) {
65 if (_NSIG_WORDS == 1) {
66 if (__get_user(set.sig[0], &ucp->uc_sigmask.sig[0]))
69 if (__copy_from_user(&set, &ucp->uc_sigmask, sizeof(sigset_t)))
72 sigdelsetmask(&set, ~_BLOCKABLE);
73 spin_lock_irq(¤t->sighand->siglock);
74 current->blocked = set;
76 spin_unlock_irq(¤t->sighand->siglock);
78 if (test_thread_flag(TIF_32BIT)) {
84 err |= __get_user(regs->y, &((*grp)[MC_Y]));
85 err |= __get_user(tstate, &((*grp)[MC_TSTATE]));
86 regs->tstate &= ~(TSTATE_ICC | TSTATE_XCC);
87 regs->tstate |= (tstate & (TSTATE_ICC | TSTATE_XCC));
88 err |= __get_user(regs->u_regs[UREG_G1], (&(*grp)[MC_G1]));
89 err |= __get_user(regs->u_regs[UREG_G2], (&(*grp)[MC_G2]));
90 err |= __get_user(regs->u_regs[UREG_G3], (&(*grp)[MC_G3]));
91 err |= __get_user(regs->u_regs[UREG_G4], (&(*grp)[MC_G4]));
92 err |= __get_user(regs->u_regs[UREG_G5], (&(*grp)[MC_G5]));
93 err |= __get_user(regs->u_regs[UREG_G6], (&(*grp)[MC_G6]));
94 err |= __get_user(regs->u_regs[UREG_G7], (&(*grp)[MC_G7]));
95 err |= __get_user(regs->u_regs[UREG_I0], (&(*grp)[MC_O0]));
96 err |= __get_user(regs->u_regs[UREG_I1], (&(*grp)[MC_O1]));
97 err |= __get_user(regs->u_regs[UREG_I2], (&(*grp)[MC_O2]));
98 err |= __get_user(regs->u_regs[UREG_I3], (&(*grp)[MC_O3]));
99 err |= __get_user(regs->u_regs[UREG_I4], (&(*grp)[MC_O4]));
100 err |= __get_user(regs->u_regs[UREG_I5], (&(*grp)[MC_O5]));
101 err |= __get_user(regs->u_regs[UREG_I6], (&(*grp)[MC_O6]));
102 err |= __get_user(regs->u_regs[UREG_I7], (&(*grp)[MC_O7]));
104 err |= __get_user(fp, &(ucp->uc_mcontext.mc_fp));
105 err |= __get_user(i7, &(ucp->uc_mcontext.mc_i7));
106 err |= __put_user(fp,
107 (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[6])));
108 err |= __put_user(i7,
109 (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[7])));
111 err |= __get_user(fenab, &(ucp->uc_mcontext.mc_fpregs.mcfpu_enab));
113 unsigned long *fpregs = current_thread_info()->fpregs;
117 err |= __get_user(fprs, &(ucp->uc_mcontext.mc_fpregs.mcfpu_fprs));
119 err |= copy_from_user(fpregs,
120 &(ucp->uc_mcontext.mc_fpregs.mcfpu_fregs),
121 (sizeof(unsigned int) * 32));
123 err |= copy_from_user(fpregs+16,
124 ((unsigned long __user *)&(ucp->uc_mcontext.mc_fpregs.mcfpu_fregs))+16,
125 (sizeof(unsigned int) * 32));
126 err |= __get_user(current_thread_info()->xfsr[0],
127 &(ucp->uc_mcontext.mc_fpregs.mcfpu_fsr));
128 err |= __get_user(current_thread_info()->gsr[0],
129 &(ucp->uc_mcontext.mc_fpregs.mcfpu_gsr));
130 regs->tstate &= ~TSTATE_PEF;
140 asmlinkage void sparc64_get_context(struct pt_regs *regs)
142 struct ucontext *ucp = (struct ucontext __user *) regs->u_regs[UREG_I0];
143 mc_gregset_t __user *grp;
144 mcontext_t __user *mcp;
145 unsigned long fp, i7;
149 synchronize_user_stack();
150 if (get_thread_wsaved() || clear_user(ucp, sizeof(*ucp)))
154 fenab = 0; /* IMO get_context is like any other system call, thus modifies FPU state -jj */
156 fenab = (current_thread_info()->fpsaved[0] & FPRS_FEF);
159 mcp = &ucp->uc_mcontext;
160 grp = &mcp->mc_gregs;
162 /* Skip over the trap instruction, first. */
163 if (test_thread_flag(TIF_32BIT)) {
164 regs->tpc = (regs->tnpc & 0xffffffff);
165 regs->tnpc = (regs->tnpc + 4) & 0xffffffff;
167 regs->tpc = regs->tnpc;
171 if (_NSIG_WORDS == 1)
172 err |= __put_user(current->blocked.sig[0],
173 (unsigned long __user *)&ucp->uc_sigmask);
175 err |= __copy_to_user(&ucp->uc_sigmask, ¤t->blocked,
178 err |= __put_user(regs->tstate, &((*grp)[MC_TSTATE]));
179 err |= __put_user(regs->tpc, &((*grp)[MC_PC]));
180 err |= __put_user(regs->tnpc, &((*grp)[MC_NPC]));
181 err |= __put_user(regs->y, &((*grp)[MC_Y]));
182 err |= __put_user(regs->u_regs[UREG_G1], &((*grp)[MC_G1]));
183 err |= __put_user(regs->u_regs[UREG_G2], &((*grp)[MC_G2]));
184 err |= __put_user(regs->u_regs[UREG_G3], &((*grp)[MC_G3]));
185 err |= __put_user(regs->u_regs[UREG_G4], &((*grp)[MC_G4]));
186 err |= __put_user(regs->u_regs[UREG_G5], &((*grp)[MC_G5]));
187 err |= __put_user(regs->u_regs[UREG_G6], &((*grp)[MC_G6]));
188 err |= __put_user(regs->u_regs[UREG_G7], &((*grp)[MC_G7]));
189 err |= __put_user(regs->u_regs[UREG_I0], &((*grp)[MC_O0]));
190 err |= __put_user(regs->u_regs[UREG_I1], &((*grp)[MC_O1]));
191 err |= __put_user(regs->u_regs[UREG_I2], &((*grp)[MC_O2]));
192 err |= __put_user(regs->u_regs[UREG_I3], &((*grp)[MC_O3]));
193 err |= __put_user(regs->u_regs[UREG_I4], &((*grp)[MC_O4]));
194 err |= __put_user(regs->u_regs[UREG_I5], &((*grp)[MC_O5]));
195 err |= __put_user(regs->u_regs[UREG_I6], &((*grp)[MC_O6]));
196 err |= __put_user(regs->u_regs[UREG_I7], &((*grp)[MC_O7]));
198 err |= __get_user(fp,
199 (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[6])));
200 err |= __get_user(i7,
201 (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[7])));
202 err |= __put_user(fp, &(mcp->mc_fp));
203 err |= __put_user(i7, &(mcp->mc_i7));
205 err |= __put_user(fenab, &(mcp->mc_fpregs.mcfpu_enab));
207 unsigned long *fpregs = current_thread_info()->fpregs;
210 fprs = current_thread_info()->fpsaved[0];
212 err |= copy_to_user(&(mcp->mc_fpregs.mcfpu_fregs), fpregs,
213 (sizeof(unsigned int) * 32));
216 ((unsigned long __user *)&(mcp->mc_fpregs.mcfpu_fregs))+16, fpregs+16,
217 (sizeof(unsigned int) * 32));
218 err |= __put_user(current_thread_info()->xfsr[0], &(mcp->mc_fpregs.mcfpu_fsr));
219 err |= __put_user(current_thread_info()->gsr[0], &(mcp->mc_fpregs.mcfpu_gsr));
220 err |= __put_user(fprs, &(mcp->mc_fpregs.mcfpu_fprs));
230 struct rt_signal_frame {
231 struct sparc_stackf ss;
234 __siginfo_fpu_t __user *fpu_save;
237 __siginfo_fpu_t fpu_state;
241 #define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame) + 7) & (~7)))
244 * atomically swap in the new signal mask, and wait for a signal.
245 * This is really tricky on the Sparc, watch out...
247 asmlinkage void _sigpause_common(old_sigset_t set, struct pt_regs *regs)
251 #ifdef CONFIG_SPARC32_COMPAT
252 if (test_thread_flag(TIF_32BIT)) {
253 extern asmlinkage void _sigpause32_common(compat_old_sigset_t,
255 _sigpause32_common(set, regs);
260 spin_lock_irq(¤t->sighand->siglock);
261 saveset = current->blocked;
262 siginitset(¤t->blocked, set);
264 spin_unlock_irq(¤t->sighand->siglock);
266 if (test_thread_flag(TIF_32BIT)) {
267 regs->tpc = (regs->tnpc & 0xffffffff);
268 regs->tnpc = (regs->tnpc + 4) & 0xffffffff;
270 regs->tpc = regs->tnpc;
274 /* Condition codes and return value where set here for sigpause,
275 * and so got used by setup_frame, which again causes sigreturn()
279 current->state = TASK_INTERRUPTIBLE;
282 * Return -EINTR and set condition code here,
283 * so the interrupted system call actually returns
286 regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
287 regs->u_regs[UREG_I0] = EINTR;
288 if (do_signal(&saveset, regs, 0, 0))
293 asmlinkage void do_sigpause(unsigned int set, struct pt_regs *regs)
295 _sigpause_common(set, regs);
298 asmlinkage void do_sigsuspend(struct pt_regs *regs)
300 _sigpause_common(regs->u_regs[UREG_I0], regs);
303 asmlinkage void do_rt_sigsuspend(sigset_t __user *uset, size_t sigsetsize, struct pt_regs *regs)
305 sigset_t oldset, set;
307 /* XXX: Don't preclude handling different sized sigset_t's. */
308 if (sigsetsize != sizeof(sigset_t)) {
309 regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
310 regs->u_regs[UREG_I0] = EINVAL;
313 if (copy_from_user(&set, uset, sizeof(set))) {
314 regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
315 regs->u_regs[UREG_I0] = EFAULT;
319 sigdelsetmask(&set, ~_BLOCKABLE);
320 spin_lock_irq(¤t->sighand->siglock);
321 oldset = current->blocked;
322 current->blocked = set;
324 spin_unlock_irq(¤t->sighand->siglock);
326 if (test_thread_flag(TIF_32BIT)) {
327 regs->tpc = (regs->tnpc & 0xffffffff);
328 regs->tnpc = (regs->tnpc + 4) & 0xffffffff;
330 regs->tpc = regs->tnpc;
334 /* Condition codes and return value where set here for sigpause,
335 * and so got used by setup_frame, which again causes sigreturn()
339 current->state = TASK_INTERRUPTIBLE;
342 * Return -EINTR and set condition code here,
343 * so the interrupted system call actually returns
346 regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
347 regs->u_regs[UREG_I0] = EINTR;
348 if (do_signal(&oldset, regs, 0, 0))
354 restore_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
356 unsigned long *fpregs = current_thread_info()->fpregs;
360 err = __get_user(fprs, &fpu->si_fprs);
362 regs->tstate &= ~TSTATE_PEF;
364 err |= copy_from_user(fpregs, &fpu->si_float_regs[0],
365 (sizeof(unsigned int) * 32));
367 err |= copy_from_user(fpregs+16, &fpu->si_float_regs[32],
368 (sizeof(unsigned int) * 32));
369 err |= __get_user(current_thread_info()->xfsr[0], &fpu->si_fsr);
370 err |= __get_user(current_thread_info()->gsr[0], &fpu->si_gsr);
371 current_thread_info()->fpsaved[0] |= fprs;
375 void do_rt_sigreturn(struct pt_regs *regs)
377 struct rt_signal_frame __user *sf;
378 unsigned long tpc, tnpc, tstate;
379 __siginfo_fpu_t __user *fpu_save;
385 /* Always make any pending restarted system calls return -EINTR */
386 current_thread_info()->restart_block.fn = do_no_restart_syscall;
388 synchronize_user_stack ();
389 sf = (struct rt_signal_frame __user *)
390 (regs->u_regs [UREG_FP] + STACK_BIAS);
392 /* 1. Make sure we are not getting garbage from the user */
393 if (((unsigned long) sf) & 3)
396 err = get_user(tpc, &sf->regs.tpc);
397 err |= __get_user(tnpc, &sf->regs.tnpc);
398 if (test_thread_flag(TIF_32BIT)) {
402 err |= ((tpc | tnpc) & 3);
404 /* 2. Restore the state */
405 err |= __get_user(regs->y, &sf->regs.y);
406 err |= __get_user(tstate, &sf->regs.tstate);
407 err |= copy_from_user(regs->u_regs, sf->regs.u_regs, sizeof(regs->u_regs));
409 /* User can only change condition codes in %tstate. */
410 regs->tstate &= ~(TSTATE_ICC | TSTATE_XCC);
411 regs->tstate |= (tstate & (TSTATE_ICC | TSTATE_XCC));
413 err |= __get_user(fpu_save, &sf->fpu_save);
415 err |= restore_fpu_state(regs, &sf->fpu_state);
417 err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t));
418 err |= __copy_from_user(&st, &sf->stack, sizeof(stack_t));
426 /* It is more difficult to avoid calling this function than to
427 call it and ignore errors. */
430 do_sigaltstack(&st, NULL, (unsigned long)sf);
433 sigdelsetmask(&set, ~_BLOCKABLE);
434 spin_lock_irq(¤t->sighand->siglock);
435 current->blocked = set;
437 spin_unlock_irq(¤t->sighand->siglock);
440 send_sig(SIGSEGV, current, 1);
443 /* Checks if the fp is valid */
444 static int invalid_frame_pointer(void __user *fp, int fplen)
446 if (((unsigned long) fp) & 7)
452 save_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
454 unsigned long *fpregs = (unsigned long *)(regs+1);
458 fprs = current_thread_info()->fpsaved[0];
460 err |= copy_to_user(&fpu->si_float_regs[0], fpregs,
461 (sizeof(unsigned int) * 32));
463 err |= copy_to_user(&fpu->si_float_regs[32], fpregs+16,
464 (sizeof(unsigned int) * 32));
465 err |= __put_user(current_thread_info()->xfsr[0], &fpu->si_fsr);
466 err |= __put_user(current_thread_info()->gsr[0], &fpu->si_gsr);
467 err |= __put_user(fprs, &fpu->si_fprs);
472 static inline void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, unsigned long framesize)
476 sp = regs->u_regs[UREG_FP] + STACK_BIAS;
478 /* This is the X/Open sanctioned signal stack switching. */
479 if (ka->sa.sa_flags & SA_ONSTACK) {
480 if (!on_sig_stack(sp) &&
481 !((current->sas_ss_sp + current->sas_ss_size) & 7))
482 sp = current->sas_ss_sp + current->sas_ss_size;
484 return (void __user *)(sp - framesize);
488 setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,
489 int signo, sigset_t *oldset, siginfo_t *info)
491 struct rt_signal_frame __user *sf;
492 int sigframe_size, err;
494 /* 1. Make sure everything is clean */
495 synchronize_user_stack();
496 save_and_clear_fpu();
498 sigframe_size = RT_ALIGNEDSZ;
499 if (!(current_thread_info()->fpsaved[0] & FPRS_FEF))
500 sigframe_size -= sizeof(__siginfo_fpu_t);
502 sf = (struct rt_signal_frame __user *)
503 get_sigframe(ka, regs, sigframe_size);
505 if (invalid_frame_pointer (sf, sigframe_size))
508 if (get_thread_wsaved() != 0)
511 /* 2. Save the current process state */
512 err = copy_to_user(&sf->regs, regs, sizeof (*regs));
514 if (current_thread_info()->fpsaved[0] & FPRS_FEF) {
515 err |= save_fpu_state(regs, &sf->fpu_state);
516 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
518 err |= __put_user(0, &sf->fpu_save);
521 /* Setup sigaltstack */
522 err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
523 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
524 err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);
526 err |= copy_to_user(&sf->mask, oldset, sizeof(sigset_t));
528 err |= copy_in_user((u64 __user *)sf,
529 (u64 __user *)(regs->u_regs[UREG_FP]+STACK_BIAS),
530 sizeof(struct reg_window));
533 err |= copy_siginfo_to_user(&sf->info, info);
535 err |= __put_user(signo, &sf->info.si_signo);
536 err |= __put_user(SI_NOINFO, &sf->info.si_code);
541 /* 3. signal handler back-trampoline and parameters */
542 regs->u_regs[UREG_FP] = ((unsigned long) sf) - STACK_BIAS;
543 regs->u_regs[UREG_I0] = signo;
544 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
546 /* 5. signal handler */
547 regs->tpc = (unsigned long) ka->sa.sa_handler;
548 regs->tnpc = (regs->tpc + 4);
549 if (test_thread_flag(TIF_32BIT)) {
550 regs->tpc &= 0xffffffff;
551 regs->tnpc &= 0xffffffff;
553 /* 4. return to kernel instructions */
554 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
563 static inline void handle_signal(unsigned long signr, struct k_sigaction *ka,
565 sigset_t *oldset, struct pt_regs *regs)
567 setup_rt_frame(ka, regs, signr, oldset,
568 (ka->sa.sa_flags & SA_SIGINFO) ? info : NULL);
569 if (ka->sa.sa_flags & SA_ONESHOT)
570 ka->sa.sa_handler = SIG_DFL;
571 if (!(ka->sa.sa_flags & SA_NOMASK)) {
572 spin_lock_irq(¤t->sighand->siglock);
573 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
574 sigaddset(¤t->blocked,signr);
576 spin_unlock_irq(¤t->sighand->siglock);
580 static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs,
581 struct sigaction *sa)
583 switch (regs->u_regs[UREG_I0]) {
584 case ERESTART_RESTARTBLOCK:
586 no_system_call_restart:
587 regs->u_regs[UREG_I0] = EINTR;
588 regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
591 if (!(sa->sa_flags & SA_RESTART))
592 goto no_system_call_restart;
595 regs->u_regs[UREG_I0] = orig_i0;
601 /* Note that 'init' is a special process: it doesn't get signals it doesn't
602 * want to handle. Thus you cannot kill init even with a SIGKILL even by
605 static int do_signal(sigset_t *oldset, struct pt_regs * regs,
606 unsigned long orig_i0, int restart_syscall)
609 struct signal_deliver_cookie cookie;
612 cookie.restart_syscall = restart_syscall;
613 cookie.orig_i0 = orig_i0;
616 oldset = ¤t->blocked;
618 #ifdef CONFIG_SPARC32_COMPAT
619 if (test_thread_flag(TIF_32BIT)) {
620 extern int do_signal32(sigset_t *, struct pt_regs *,
622 return do_signal32(oldset, regs, orig_i0,
623 cookie.restart_syscall);
627 signr = get_signal_to_deliver(&info, regs, &cookie);
629 struct k_sigaction *ka;
631 ka = ¤t->sighand->action[signr-1];
633 if (cookie.restart_syscall)
634 syscall_restart(orig_i0, regs, &ka->sa);
635 handle_signal(signr, ka, &info, oldset, regs);
638 if (cookie.restart_syscall &&
639 (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
640 regs->u_regs[UREG_I0] == ERESTARTSYS ||
641 regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
642 /* replay the system call when we are done */
643 regs->u_regs[UREG_I0] = cookie.orig_i0;
647 if (cookie.restart_syscall &&
648 regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
649 regs->u_regs[UREG_G1] = __NR_restart_syscall;
656 void do_notify_resume(sigset_t *oldset, struct pt_regs *regs,
657 unsigned long orig_i0, int restart_syscall,
658 unsigned long thread_info_flags)
660 if (thread_info_flags & _TIF_SIGPENDING)
661 do_signal(oldset, regs, orig_i0, restart_syscall);
664 void ptrace_signal_deliver(struct pt_regs *regs, void *cookie)
666 struct signal_deliver_cookie *cp = cookie;
668 if (cp->restart_syscall &&
669 (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
670 regs->u_regs[UREG_I0] == ERESTARTSYS ||
671 regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
672 /* replay the system call when we are done */
673 regs->u_regs[UREG_I0] = cp->orig_i0;
676 cp->restart_syscall = 0;
678 if (cp->restart_syscall &&
679 regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
680 regs->u_regs[UREG_G1] = __NR_restart_syscall;
683 cp->restart_syscall = 0;