Merge branch 'drm-fixes' of master.kernel.org:/pub/scm/linux/kernel/git/airlied/drm-2.6
[linux-2.6] / arch / s390 / kernel / compat_signal.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/config.h>
15 #include <linux/compat.h>
16 #include <linux/sched.h>
17 #include <linux/mm.h>
18 #include <linux/smp.h>
19 #include <linux/smp_lock.h>
20 #include <linux/kernel.h>
21 #include <linux/signal.h>
22 #include <linux/errno.h>
23 #include <linux/wait.h>
24 #include <linux/ptrace.h>
25 #include <linux/unistd.h>
26 #include <linux/stddef.h>
27 #include <linux/tty.h>
28 #include <linux/personality.h>
29 #include <linux/binfmts.h>
30 #include <asm/ucontext.h>
31 #include <asm/uaccess.h>
32 #include <asm/lowcore.h>
33 #include "compat_linux.h"
34 #include "compat_ptrace.h"
35
36 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
37
38 typedef struct 
39 {
40         __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
41         struct sigcontext32 sc;
42         _sigregs32 sregs;
43         int signo;
44         __u8 retcode[S390_SYSCALL_SIZE];
45 } sigframe32;
46
47 typedef struct 
48 {
49         __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
50         __u8 retcode[S390_SYSCALL_SIZE];
51         compat_siginfo_t 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 copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
58 {
59         int err;
60
61         if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
62                 return -EFAULT;
63
64         /* If you change siginfo_t structure, please be sure
65            this code is fixed accordingly.
66            It should never copy any pad contained in the structure
67            to avoid security leaks, but must copy the generic
68            3 ints plus the relevant union member.  
69            This routine must convert siginfo from 64bit to 32bit as well
70            at the same time.  */
71         err = __put_user(from->si_signo, &to->si_signo);
72         err |= __put_user(from->si_errno, &to->si_errno);
73         err |= __put_user((short)from->si_code, &to->si_code);
74         if (from->si_code < 0)
75                 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
76         else {
77                 switch (from->si_code >> 16) {
78                 case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
79                 case __SI_MESGQ >> 16:
80                         err |= __put_user(from->si_int, &to->si_int);
81                         /* fallthrough */
82                 case __SI_KILL >> 16:
83                         err |= __put_user(from->si_pid, &to->si_pid);
84                         err |= __put_user(from->si_uid, &to->si_uid);
85                         break;
86                 case __SI_CHLD >> 16:
87                         err |= __put_user(from->si_pid, &to->si_pid);
88                         err |= __put_user(from->si_uid, &to->si_uid);
89                         err |= __put_user(from->si_utime, &to->si_utime);
90                         err |= __put_user(from->si_stime, &to->si_stime);
91                         err |= __put_user(from->si_status, &to->si_status);
92                         break;
93                 case __SI_FAULT >> 16:
94                         err |= __put_user((unsigned long) from->si_addr,
95                                           &to->si_addr);
96                         break;
97                 case __SI_POLL >> 16:
98                         err |= __put_user(from->si_band, &to->si_band);
99                         err |= __put_user(from->si_fd, &to->si_fd);
100                         break;
101                 case __SI_TIMER >> 16:
102                         err |= __put_user(from->si_tid, &to->si_tid);
103                         err |= __put_user(from->si_overrun, &to->si_overrun);
104                         err |= __put_user(from->si_int, &to->si_int);
105                         break;
106                 default:
107                         break;
108                 }
109         }
110         return err;
111 }
112
113 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
114 {
115         int err;
116         u32 tmp;
117
118         if (!access_ok (VERIFY_READ, from, sizeof(compat_siginfo_t)))
119                 return -EFAULT;
120
121         err = __get_user(to->si_signo, &from->si_signo);
122         err |= __get_user(to->si_errno, &from->si_errno);
123         err |= __get_user(to->si_code, &from->si_code);
124
125         if (to->si_code < 0)
126                 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
127         else {
128                 switch (to->si_code >> 16) {
129                 case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
130                 case __SI_MESGQ >> 16:
131                         err |= __get_user(to->si_int, &from->si_int);
132                         /* fallthrough */
133                 case __SI_KILL >> 16:
134                         err |= __get_user(to->si_pid, &from->si_pid);
135                         err |= __get_user(to->si_uid, &from->si_uid);
136                         break;
137                 case __SI_CHLD >> 16:
138                         err |= __get_user(to->si_pid, &from->si_pid);
139                         err |= __get_user(to->si_uid, &from->si_uid);
140                         err |= __get_user(to->si_utime, &from->si_utime);
141                         err |= __get_user(to->si_stime, &from->si_stime);
142                         err |= __get_user(to->si_status, &from->si_status);
143                         break;
144                 case __SI_FAULT >> 16:
145                         err |= __get_user(tmp, &from->si_addr);
146                         to->si_addr = (void *)(u64) (tmp & PSW32_ADDR_INSN);
147                         break;
148                 case __SI_POLL >> 16:
149                         err |= __get_user(to->si_band, &from->si_band);
150                         err |= __get_user(to->si_fd, &from->si_fd);
151                         break;
152                 case __SI_TIMER >> 16:
153                         err |= __get_user(to->si_tid, &from->si_tid);
154                         err |= __get_user(to->si_overrun, &from->si_overrun);
155                         err |= __get_user(to->si_int, &from->si_int);
156                         break;
157                 default:
158                         break;
159                 }
160         }
161         return err;
162 }
163
164 /*
165  * Atomically swap in the new signal mask, and wait for a signal.
166  */
167 asmlinkage int
168 sys32_sigsuspend(struct pt_regs * regs,int history0, int history1, old_sigset_t mask)
169 {
170         sigset_t saveset;
171
172         mask &= _BLOCKABLE;
173         spin_lock_irq(&current->sighand->siglock);
174         saveset = current->blocked;
175         siginitset(&current->blocked, mask);
176         recalc_sigpending();
177         spin_unlock_irq(&current->sighand->siglock);
178         regs->gprs[2] = -EINTR;
179
180         while (1) {
181                 set_current_state(TASK_INTERRUPTIBLE);
182                 schedule();
183                 if (do_signal(regs, &saveset))
184                         return -EINTR;
185         }
186 }
187
188 asmlinkage int
189 sys32_rt_sigsuspend(struct pt_regs * regs, compat_sigset_t __user *unewset,
190                                                                 size_t sigsetsize)
191 {
192         sigset_t saveset, newset;
193         compat_sigset_t set32;
194
195         /* XXX: Don't preclude handling different sized sigset_t's.  */
196         if (sigsetsize != sizeof(sigset_t))
197                 return -EINVAL;
198
199         if (copy_from_user(&set32, unewset, sizeof(set32)))
200                 return -EFAULT;
201         switch (_NSIG_WORDS) {
202         case 4: newset.sig[3] = set32.sig[6] + (((long)set32.sig[7]) << 32);
203         case 3: newset.sig[2] = set32.sig[4] + (((long)set32.sig[5]) << 32);
204         case 2: newset.sig[1] = set32.sig[2] + (((long)set32.sig[3]) << 32);
205         case 1: newset.sig[0] = set32.sig[0] + (((long)set32.sig[1]) << 32);
206         }
207         sigdelsetmask(&newset, ~_BLOCKABLE);
208
209         spin_lock_irq(&current->sighand->siglock);
210         saveset = current->blocked;
211         current->blocked = newset;
212         recalc_sigpending();
213         spin_unlock_irq(&current->sighand->siglock);
214         regs->gprs[2] = -EINTR;
215
216         while (1) {
217                 set_current_state(TASK_INTERRUPTIBLE);
218                 schedule();
219                 if (do_signal(regs, &saveset))
220                         return -EINTR;
221         }
222 }
223
224 asmlinkage long
225 sys32_sigaction(int sig, const struct old_sigaction32 __user *act,
226                  struct old_sigaction32 __user *oact)
227 {
228         struct k_sigaction new_ka, old_ka;
229         unsigned long sa_handler, sa_restorer;
230         int ret;
231
232         if (act) {
233                 compat_old_sigset_t mask;
234                 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
235                     __get_user(sa_handler, &act->sa_handler) ||
236                     __get_user(sa_restorer, &act->sa_restorer))
237                         return -EFAULT;
238                 new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
239                 new_ka.sa.sa_restorer = (void (*)(void)) sa_restorer;
240                 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
241                 __get_user(mask, &act->sa_mask);
242                 siginitset(&new_ka.sa.sa_mask, mask);
243         }
244
245         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
246
247         if (!ret && oact) {
248                 sa_handler = (unsigned long) old_ka.sa.sa_handler;
249                 sa_restorer = (unsigned long) old_ka.sa.sa_restorer;
250                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
251                     __put_user(sa_handler, &oact->sa_handler) ||
252                     __put_user(sa_restorer, &oact->sa_restorer))
253                         return -EFAULT;
254                 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
255                 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
256         }
257
258         return ret;
259 }
260
261 int
262 do_sigaction(int sig, const struct k_sigaction *act, struct k_sigaction *oact);
263
264 asmlinkage long
265 sys32_rt_sigaction(int sig, const struct sigaction32 __user *act,
266            struct sigaction32 __user *oact,  size_t sigsetsize)
267 {
268         struct k_sigaction new_ka, old_ka;
269         unsigned long sa_handler;
270         int ret;
271         compat_sigset_t set32;
272
273         /* XXX: Don't preclude handling different sized sigset_t's.  */
274         if (sigsetsize != sizeof(compat_sigset_t))
275                 return -EINVAL;
276
277         if (act) {
278                 ret = get_user(sa_handler, &act->sa_handler);
279                 ret |= __copy_from_user(&set32, &act->sa_mask,
280                                         sizeof(compat_sigset_t));
281                 switch (_NSIG_WORDS) {
282                 case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6]
283                                 | (((long)set32.sig[7]) << 32);
284                 case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4]
285                                 | (((long)set32.sig[5]) << 32);
286                 case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2]
287                                 | (((long)set32.sig[3]) << 32);
288                 case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0]
289                                 | (((long)set32.sig[1]) << 32);
290                 }
291                 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
292                 
293                 if (ret)
294                         return -EFAULT;
295                 new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
296         }
297
298         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
299
300         if (!ret && oact) {
301                 switch (_NSIG_WORDS) {
302                 case 4:
303                         set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32);
304                         set32.sig[6] = old_ka.sa.sa_mask.sig[3];
305                 case 3:
306                         set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32);
307                         set32.sig[4] = old_ka.sa.sa_mask.sig[2];
308                 case 2:
309                         set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32);
310                         set32.sig[2] = old_ka.sa.sa_mask.sig[1];
311                 case 1:
312                         set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32);
313                         set32.sig[0] = old_ka.sa.sa_mask.sig[0];
314                 }
315                 ret = put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler);
316                 ret |= __copy_to_user(&oact->sa_mask, &set32,
317                                       sizeof(compat_sigset_t));
318                 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
319         }
320
321         return ret;
322 }
323
324 asmlinkage long
325 sys32_sigaltstack(const stack_t32 __user *uss, stack_t32 __user *uoss,
326                                                         struct pt_regs *regs)
327 {
328         stack_t kss, koss;
329         unsigned long ss_sp;
330         int ret, err = 0;
331         mm_segment_t old_fs = get_fs();
332
333         if (uss) {
334                 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
335                         return -EFAULT;
336                 err |= __get_user(ss_sp, &uss->ss_sp);
337                 err |= __get_user(kss.ss_size, &uss->ss_size);
338                 err |= __get_user(kss.ss_flags, &uss->ss_flags);
339                 if (err)
340                         return -EFAULT;
341                 kss.ss_sp = (void *) ss_sp;
342         }
343
344         set_fs (KERNEL_DS);
345         ret = do_sigaltstack((stack_t __user *) (uss ? &kss : NULL),
346                              (stack_t __user *) (uoss ? &koss : NULL),
347                              regs->gprs[15]);
348         set_fs (old_fs);
349
350         if (!ret && uoss) {
351                 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
352                         return -EFAULT;
353                 ss_sp = (unsigned long) koss.ss_sp;
354                 err |= __put_user(ss_sp, &uoss->ss_sp);
355                 err |= __put_user(koss.ss_size, &uoss->ss_size);
356                 err |= __put_user(koss.ss_flags, &uoss->ss_flags);
357                 if (err)
358                         return -EFAULT;
359         }
360         return ret;
361 }
362
363 static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs)
364 {
365         _s390_regs_common32 regs32;
366         int err, i;
367
368         regs32.psw.mask = PSW32_MASK_MERGE(PSW32_USER_BITS,
369                                            (__u32)(regs->psw.mask >> 32));
370         regs32.psw.addr = PSW32_ADDR_AMODE31 | (__u32) regs->psw.addr;
371         for (i = 0; i < NUM_GPRS; i++)
372                 regs32.gprs[i] = (__u32) regs->gprs[i];
373         save_access_regs(current->thread.acrs);
374         memcpy(regs32.acrs, current->thread.acrs, sizeof(regs32.acrs));
375         err = __copy_to_user(&sregs->regs, &regs32, sizeof(regs32));
376         if (err)
377                 return err;
378         save_fp_regs(&current->thread.fp_regs);
379         /* s390_fp_regs and _s390_fp_regs32 are the same ! */
380         return __copy_to_user(&sregs->fpregs, &current->thread.fp_regs,
381                               sizeof(_s390_fp_regs32));
382 }
383
384 static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs)
385 {
386         _s390_regs_common32 regs32;
387         int err, i;
388
389         /* Alwys make any pending restarted system call return -EINTR */
390         current_thread_info()->restart_block.fn = do_no_restart_syscall;
391
392         err = __copy_from_user(&regs32, &sregs->regs, sizeof(regs32));
393         if (err)
394                 return err;
395         regs->psw.mask = PSW_MASK_MERGE(regs->psw.mask,
396                                         (__u64)regs32.psw.mask << 32);
397         regs->psw.addr = (__u64)(regs32.psw.addr & PSW32_ADDR_INSN);
398         for (i = 0; i < NUM_GPRS; i++)
399                 regs->gprs[i] = (__u64) regs32.gprs[i];
400         memcpy(current->thread.acrs, regs32.acrs, sizeof(current->thread.acrs));
401         restore_access_regs(current->thread.acrs);
402
403         err = __copy_from_user(&current->thread.fp_regs, &sregs->fpregs,
404                                sizeof(_s390_fp_regs32));
405         current->thread.fp_regs.fpc &= FPC_VALID_MASK;
406         if (err)
407                 return err;
408
409         restore_fp_regs(&current->thread.fp_regs);
410         regs->trap = -1;        /* disable syscall checks */
411         return 0;
412 }
413
414 asmlinkage long sys32_sigreturn(struct pt_regs *regs)
415 {
416         sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
417         sigset_t set;
418
419         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
420                 goto badframe;
421         if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
422                 goto badframe;
423
424         sigdelsetmask(&set, ~_BLOCKABLE);
425         spin_lock_irq(&current->sighand->siglock);
426         current->blocked = set;
427         recalc_sigpending();
428         spin_unlock_irq(&current->sighand->siglock);
429
430         if (restore_sigregs32(regs, &frame->sregs))
431                 goto badframe;
432
433         return regs->gprs[2];
434
435 badframe:
436         force_sig(SIGSEGV, current);
437         return 0;
438 }
439
440 asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
441 {
442         rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
443         sigset_t set;
444         stack_t st;
445         __u32 ss_sp;
446         int err;
447         mm_segment_t old_fs = get_fs();
448
449         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
450                 goto badframe;
451         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
452                 goto badframe;
453
454         sigdelsetmask(&set, ~_BLOCKABLE);
455         spin_lock_irq(&current->sighand->siglock);
456         current->blocked = set;
457         recalc_sigpending();
458         spin_unlock_irq(&current->sighand->siglock);
459
460         if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
461                 goto badframe;
462
463         err = __get_user(ss_sp, &frame->uc.uc_stack.ss_sp);
464         st.ss_sp = (void *) A((unsigned long)ss_sp);
465         err |= __get_user(st.ss_size, &frame->uc.uc_stack.ss_size);
466         err |= __get_user(st.ss_flags, &frame->uc.uc_stack.ss_flags);
467         if (err)
468                 goto badframe; 
469
470         /* It is more difficult to avoid calling this function than to
471            call it and ignore errors.  */
472         set_fs (KERNEL_DS);
473         do_sigaltstack((stack_t __user *)&st, NULL, regs->gprs[15]);
474         set_fs (old_fs);
475
476         return regs->gprs[2];
477
478 badframe:
479         force_sig(SIGSEGV, current);
480         return 0;
481 }       
482
483 /*
484  * Set up a signal frame.
485  */
486
487
488 /*
489  * Determine which stack to use..
490  */
491 static inline void __user *
492 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
493 {
494         unsigned long sp;
495
496         /* Default to using normal stack */
497         sp = (unsigned long) A(regs->gprs[15]);
498
499         /* This is the X/Open sanctioned signal stack switching.  */
500         if (ka->sa.sa_flags & SA_ONSTACK) {
501                 if (! on_sig_stack(sp))
502                         sp = current->sas_ss_sp + current->sas_ss_size;
503         }
504
505         /* This is the legacy signal stack switching. */
506         else if (!user_mode(regs) &&
507                  !(ka->sa.sa_flags & SA_RESTORER) &&
508                  ka->sa.sa_restorer) {
509                 sp = (unsigned long) ka->sa.sa_restorer;
510         }
511
512         return (void __user *)((sp - frame_size) & -8ul);
513 }
514
515 static inline int map_signal(int sig)
516 {
517         if (current_thread_info()->exec_domain
518             && current_thread_info()->exec_domain->signal_invmap
519             && sig < 32)
520                 return current_thread_info()->exec_domain->signal_invmap[sig];
521         else
522                 return sig;
523 }
524
525 static void setup_frame32(int sig, struct k_sigaction *ka,
526                         sigset_t *set, struct pt_regs * regs)
527 {
528         sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32));
529         if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe32)))
530                 goto give_sigsegv;
531
532         if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32))
533                 goto give_sigsegv;
534
535         if (save_sigregs32(regs, &frame->sregs))
536                 goto give_sigsegv;
537         if (__put_user((unsigned long) &frame->sregs, &frame->sc.sregs))
538                 goto give_sigsegv;
539
540         /* Set up to return from userspace.  If provided, use a stub
541            already in userspace.  */
542         if (ka->sa.sa_flags & SA_RESTORER) {
543                 regs->gprs[14] = (__u64) ka->sa.sa_restorer;
544         } else {
545                 regs->gprs[14] = (__u64) frame->retcode;
546                 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
547                                (u16 __user *)(frame->retcode)))
548                         goto give_sigsegv;
549         }
550
551         /* Set up backchain. */
552         if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
553                 goto give_sigsegv;
554
555         /* Set up registers for signal handler */
556         regs->gprs[15] = (__u64) frame;
557         regs->psw.addr = (__u64) ka->sa.sa_handler;
558
559         regs->gprs[2] = map_signal(sig);
560         regs->gprs[3] = (__u64) &frame->sc;
561
562         /* We forgot to include these in the sigcontext.
563            To avoid breaking binary compatibility, they are passed as args. */
564         regs->gprs[4] = current->thread.trap_no;
565         regs->gprs[5] = current->thread.prot_addr;
566
567         /* Place signal number on stack to allow backtrace from handler.  */
568         if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
569                 goto give_sigsegv;
570         return;
571
572 give_sigsegv:
573         force_sigsegv(sig, current);
574 }
575
576 static void setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info,
577                            sigset_t *set, struct pt_regs * regs)
578 {
579         int err = 0;
580         rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32));
581         if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe32)))
582                 goto give_sigsegv;
583
584         if (copy_siginfo_to_user32(&frame->info, info))
585                 goto give_sigsegv;
586
587         /* Create the ucontext.  */
588         err |= __put_user(0, &frame->uc.uc_flags);
589         err |= __put_user(0, &frame->uc.uc_link);
590         err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
591         err |= __put_user(sas_ss_flags(regs->gprs[15]),
592                           &frame->uc.uc_stack.ss_flags);
593         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
594         err |= save_sigregs32(regs, &frame->uc.uc_mcontext);
595         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
596         if (err)
597                 goto give_sigsegv;
598
599         /* Set up to return from userspace.  If provided, use a stub
600            already in userspace.  */
601         if (ka->sa.sa_flags & SA_RESTORER) {
602                 regs->gprs[14] = (__u64) ka->sa.sa_restorer;
603         } else {
604                 regs->gprs[14] = (__u64) frame->retcode;
605                 err |= __put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
606                                   (u16 __user *)(frame->retcode));
607         }
608
609         /* Set up backchain. */
610         if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
611                 goto give_sigsegv;
612
613         /* Set up registers for signal handler */
614         regs->gprs[15] = (__u64) frame;
615         regs->psw.addr = (__u64) ka->sa.sa_handler;
616
617         regs->gprs[2] = map_signal(sig);
618         regs->gprs[3] = (__u64) &frame->info;
619         regs->gprs[4] = (__u64) &frame->uc;
620         return;
621
622 give_sigsegv:
623         force_sigsegv(sig, current);
624 }
625
626 /*
627  * OK, we're invoking a handler
628  */     
629
630 void
631 handle_signal32(unsigned long sig, struct k_sigaction *ka,
632                 siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
633 {
634         /* Set up the stack frame */
635         if (ka->sa.sa_flags & SA_SIGINFO)
636                 setup_rt_frame32(sig, ka, info, oldset, regs);
637         else
638                 setup_frame32(sig, ka, oldset, regs);
639
640         spin_lock_irq(&current->sighand->siglock);
641         sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
642         if (!(ka->sa.sa_flags & SA_NODEFER))
643                 sigaddset(&current->blocked,sig);
644         recalc_sigpending();
645         spin_unlock_irq(&current->sighand->siglock);
646 }
647