Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright IBM Corp. 2000, 2006
4 * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
5 * Gerhard Tonn (ton@de.ibm.com)
6 *
7 * Copyright (C) 1991, 1992 Linus Torvalds
8 *
9 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
10 */
11
12#include <linux/compat.h>
13#include <linux/sched.h>
14#include <linux/sched/task_stack.h>
15#include <linux/mm.h>
16#include <linux/smp.h>
17#include <linux/kernel.h>
18#include <linux/signal.h>
19#include <linux/errno.h>
20#include <linux/wait.h>
21#include <linux/ptrace.h>
22#include <linux/unistd.h>
23#include <linux/stddef.h>
24#include <linux/tty.h>
25#include <linux/personality.h>
26#include <linux/binfmts.h>
27#include <asm/ucontext.h>
28#include <linux/uaccess.h>
29#include <asm/lowcore.h>
30#include <asm/switch_to.h>
31#include "compat_linux.h"
32#include "compat_ptrace.h"
33#include "entry.h"
34
35typedef struct
36{
37 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
38 struct sigcontext32 sc;
39 _sigregs32 sregs;
40 int signo;
41 _sigregs_ext32 sregs_ext;
42 __u16 svc_insn; /* Offset of svc_insn is NOT fixed! */
43} sigframe32;
44
45typedef struct
46{
47 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
48 __u16 svc_insn;
49 compat_siginfo_t info;
50 struct ucontext32 uc;
51} rt_sigframe32;
52
53/* Store registers needed to create the signal frame */
54static void store_sigregs(void)
55{
56 save_access_regs(current->thread.acrs);
57 save_fpu_regs();
58}
59
60/* Load registers after signal return */
61static void load_sigregs(void)
62{
63 restore_access_regs(current->thread.acrs);
64}
65
66static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs)
67{
68 _sigregs32 user_sregs;
69 int i;
70
71 user_sregs.regs.psw.mask = (__u32)(regs->psw.mask >> 32);
72 user_sregs.regs.psw.mask &= PSW32_MASK_USER | PSW32_MASK_RI;
73 user_sregs.regs.psw.mask |= PSW32_USER_BITS;
74 user_sregs.regs.psw.addr = (__u32) regs->psw.addr |
75 (__u32)(regs->psw.mask & PSW_MASK_BA);
76 for (i = 0; i < NUM_GPRS; i++)
77 user_sregs.regs.gprs[i] = (__u32) regs->gprs[i];
78 memcpy(&user_sregs.regs.acrs, current->thread.acrs,
79 sizeof(user_sregs.regs.acrs));
80 fpregs_store((_s390_fp_regs *) &user_sregs.fpregs, ¤t->thread.fpu);
81 if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs32)))
82 return -EFAULT;
83 return 0;
84}
85
86static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs)
87{
88 _sigregs32 user_sregs;
89 int i;
90
91 /* Alwys make any pending restarted system call return -EINTR */
92 current->restart_block.fn = do_no_restart_syscall;
93
94 if (__copy_from_user(&user_sregs, &sregs->regs, sizeof(user_sregs)))
95 return -EFAULT;
96
97 if (!is_ri_task(current) && (user_sregs.regs.psw.mask & PSW32_MASK_RI))
98 return -EINVAL;
99
100 /* Test the floating-point-control word. */
101 if (test_fp_ctl(user_sregs.fpregs.fpc))
102 return -EINVAL;
103
104 /* Use regs->psw.mask instead of PSW_USER_BITS to preserve PER bit. */
105 regs->psw.mask = (regs->psw.mask & ~(PSW_MASK_USER | PSW_MASK_RI)) |
106 (__u64)(user_sregs.regs.psw.mask & PSW32_MASK_USER) << 32 |
107 (__u64)(user_sregs.regs.psw.mask & PSW32_MASK_RI) << 32 |
108 (__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_AMODE);
109 /* Check for invalid user address space control. */
110 if ((regs->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME)
111 regs->psw.mask = PSW_ASC_PRIMARY |
112 (regs->psw.mask & ~PSW_MASK_ASC);
113 regs->psw.addr = (__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_INSN);
114 for (i = 0; i < NUM_GPRS; i++)
115 regs->gprs[i] = (__u64) user_sregs.regs.gprs[i];
116 memcpy(¤t->thread.acrs, &user_sregs.regs.acrs,
117 sizeof(current->thread.acrs));
118 fpregs_load((_s390_fp_regs *) &user_sregs.fpregs, ¤t->thread.fpu);
119
120 clear_pt_regs_flag(regs, PIF_SYSCALL); /* No longer in a system call */
121 return 0;
122}
123
124static int save_sigregs_ext32(struct pt_regs *regs,
125 _sigregs_ext32 __user *sregs_ext)
126{
127 __u32 gprs_high[NUM_GPRS];
128 __u64 vxrs[__NUM_VXRS_LOW];
129 int i;
130
131 /* Save high gprs to signal stack */
132 for (i = 0; i < NUM_GPRS; i++)
133 gprs_high[i] = regs->gprs[i] >> 32;
134 if (__copy_to_user(&sregs_ext->gprs_high, &gprs_high,
135 sizeof(sregs_ext->gprs_high)))
136 return -EFAULT;
137
138 /* Save vector registers to signal stack */
139 if (MACHINE_HAS_VX) {
140 for (i = 0; i < __NUM_VXRS_LOW; i++)
141 vxrs[i] = *((__u64 *)(current->thread.fpu.vxrs + i) + 1);
142 if (__copy_to_user(&sregs_ext->vxrs_low, vxrs,
143 sizeof(sregs_ext->vxrs_low)) ||
144 __copy_to_user(&sregs_ext->vxrs_high,
145 current->thread.fpu.vxrs + __NUM_VXRS_LOW,
146 sizeof(sregs_ext->vxrs_high)))
147 return -EFAULT;
148 }
149 return 0;
150}
151
152static int restore_sigregs_ext32(struct pt_regs *regs,
153 _sigregs_ext32 __user *sregs_ext)
154{
155 __u32 gprs_high[NUM_GPRS];
156 __u64 vxrs[__NUM_VXRS_LOW];
157 int i;
158
159 /* Restore high gprs from signal stack */
160 if (__copy_from_user(&gprs_high, &sregs_ext->gprs_high,
161 sizeof(sregs_ext->gprs_high)))
162 return -EFAULT;
163 for (i = 0; i < NUM_GPRS; i++)
164 *(__u32 *)®s->gprs[i] = gprs_high[i];
165
166 /* Restore vector registers from signal stack */
167 if (MACHINE_HAS_VX) {
168 if (__copy_from_user(vxrs, &sregs_ext->vxrs_low,
169 sizeof(sregs_ext->vxrs_low)) ||
170 __copy_from_user(current->thread.fpu.vxrs + __NUM_VXRS_LOW,
171 &sregs_ext->vxrs_high,
172 sizeof(sregs_ext->vxrs_high)))
173 return -EFAULT;
174 for (i = 0; i < __NUM_VXRS_LOW; i++)
175 *((__u64 *)(current->thread.fpu.vxrs + i) + 1) = vxrs[i];
176 }
177 return 0;
178}
179
180COMPAT_SYSCALL_DEFINE0(sigreturn)
181{
182 struct pt_regs *regs = task_pt_regs(current);
183 sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
184 sigset_t set;
185
186 if (get_compat_sigset(&set, (compat_sigset_t __user *)frame->sc.oldmask))
187 goto badframe;
188 set_current_blocked(&set);
189 save_fpu_regs();
190 if (restore_sigregs32(regs, &frame->sregs))
191 goto badframe;
192 if (restore_sigregs_ext32(regs, &frame->sregs_ext))
193 goto badframe;
194 load_sigregs();
195 return regs->gprs[2];
196badframe:
197 force_sig(SIGSEGV);
198 return 0;
199}
200
201COMPAT_SYSCALL_DEFINE0(rt_sigreturn)
202{
203 struct pt_regs *regs = task_pt_regs(current);
204 rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
205 sigset_t set;
206
207 if (get_compat_sigset(&set, &frame->uc.uc_sigmask))
208 goto badframe;
209 set_current_blocked(&set);
210 if (compat_restore_altstack(&frame->uc.uc_stack))
211 goto badframe;
212 save_fpu_regs();
213 if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
214 goto badframe;
215 if (restore_sigregs_ext32(regs, &frame->uc.uc_mcontext_ext))
216 goto badframe;
217 load_sigregs();
218 return regs->gprs[2];
219badframe:
220 force_sig(SIGSEGV);
221 return 0;
222}
223
224/*
225 * Set up a signal frame.
226 */
227
228
229/*
230 * Determine which stack to use..
231 */
232static inline void __user *
233get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
234{
235 unsigned long sp;
236
237 /* Default to using normal stack */
238 sp = (unsigned long) A(regs->gprs[15]);
239
240 /* Overflow on alternate signal stack gives SIGSEGV. */
241 if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
242 return (void __user *) -1UL;
243
244 /* This is the X/Open sanctioned signal stack switching. */
245 if (ka->sa.sa_flags & SA_ONSTACK) {
246 if (! sas_ss_flags(sp))
247 sp = current->sas_ss_sp + current->sas_ss_size;
248 }
249
250 return (void __user *)((sp - frame_size) & -8ul);
251}
252
253static int setup_frame32(struct ksignal *ksig, sigset_t *set,
254 struct pt_regs *regs)
255{
256 int sig = ksig->sig;
257 sigframe32 __user *frame;
258 unsigned long restorer;
259 size_t frame_size;
260
261 /*
262 * gprs_high are always present for 31-bit compat tasks.
263 * The space for vector registers is only allocated if
264 * the machine supports it
265 */
266 frame_size = sizeof(*frame) - sizeof(frame->sregs_ext.__reserved);
267 if (!MACHINE_HAS_VX)
268 frame_size -= sizeof(frame->sregs_ext.vxrs_low) +
269 sizeof(frame->sregs_ext.vxrs_high);
270 frame = get_sigframe(&ksig->ka, regs, frame_size);
271 if (frame == (void __user *) -1UL)
272 return -EFAULT;
273
274 /* Set up backchain. */
275 if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
276 return -EFAULT;
277
278 /* Create struct sigcontext32 on the signal stack */
279 if (put_compat_sigset((compat_sigset_t __user *)frame->sc.oldmask,
280 set, sizeof(compat_sigset_t)))
281 return -EFAULT;
282 if (__put_user(ptr_to_compat(&frame->sregs), &frame->sc.sregs))
283 return -EFAULT;
284
285 /* Store registers needed to create the signal frame */
286 store_sigregs();
287
288 /* Create _sigregs32 on the signal stack */
289 if (save_sigregs32(regs, &frame->sregs))
290 return -EFAULT;
291
292 /* Place signal number on stack to allow backtrace from handler. */
293 if (__put_user(regs->gprs[2], (int __force __user *) &frame->signo))
294 return -EFAULT;
295
296 /* Create _sigregs_ext32 on the signal stack */
297 if (save_sigregs_ext32(regs, &frame->sregs_ext))
298 return -EFAULT;
299
300 /* Set up to return from userspace. If provided, use a stub
301 already in userspace. */
302 if (ksig->ka.sa.sa_flags & SA_RESTORER) {
303 restorer = (unsigned long __force)
304 ksig->ka.sa.sa_restorer | PSW32_ADDR_AMODE;
305 } else {
306 /* Signal frames without vectors registers are short ! */
307 __u16 __user *svc = (void __user *) frame + frame_size - 2;
308 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn, svc))
309 return -EFAULT;
310 restorer = (unsigned long __force) svc | PSW32_ADDR_AMODE;
311 }
312
313 /* Set up registers for signal handler */
314 regs->gprs[14] = restorer;
315 regs->gprs[15] = (__force __u64) frame;
316 /* Force 31 bit amode and default user address space control. */
317 regs->psw.mask = PSW_MASK_BA |
318 (PSW_USER_BITS & PSW_MASK_ASC) |
319 (regs->psw.mask & ~PSW_MASK_ASC);
320 regs->psw.addr = (__force __u64) ksig->ka.sa.sa_handler;
321
322 regs->gprs[2] = sig;
323 regs->gprs[3] = (__force __u64) &frame->sc;
324
325 /* We forgot to include these in the sigcontext.
326 To avoid breaking binary compatibility, they are passed as args. */
327 if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL ||
328 sig == SIGTRAP || sig == SIGFPE) {
329 /* set extra registers only for synchronous signals */
330 regs->gprs[4] = regs->int_code & 127;
331 regs->gprs[5] = regs->int_parm_long;
332 regs->gprs[6] = current->thread.last_break;
333 }
334
335 return 0;
336}
337
338static int setup_rt_frame32(struct ksignal *ksig, sigset_t *set,
339 struct pt_regs *regs)
340{
341 rt_sigframe32 __user *frame;
342 unsigned long restorer;
343 size_t frame_size;
344 u32 uc_flags;
345
346 frame_size = sizeof(*frame) -
347 sizeof(frame->uc.uc_mcontext_ext.__reserved);
348 /*
349 * gprs_high are always present for 31-bit compat tasks.
350 * The space for vector registers is only allocated if
351 * the machine supports it
352 */
353 uc_flags = UC_GPRS_HIGH;
354 if (MACHINE_HAS_VX) {
355 uc_flags |= UC_VXRS;
356 } else
357 frame_size -= sizeof(frame->uc.uc_mcontext_ext.vxrs_low) +
358 sizeof(frame->uc.uc_mcontext_ext.vxrs_high);
359 frame = get_sigframe(&ksig->ka, regs, frame_size);
360 if (frame == (void __user *) -1UL)
361 return -EFAULT;
362
363 /* Set up backchain. */
364 if (__put_user(regs->gprs[15], (unsigned int __force __user *) frame))
365 return -EFAULT;
366
367 /* Set up to return from userspace. If provided, use a stub
368 already in userspace. */
369 if (ksig->ka.sa.sa_flags & SA_RESTORER) {
370 restorer = (unsigned long __force)
371 ksig->ka.sa.sa_restorer | PSW32_ADDR_AMODE;
372 } else {
373 __u16 __user *svc = &frame->svc_insn;
374 if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn, svc))
375 return -EFAULT;
376 restorer = (unsigned long __force) svc | PSW32_ADDR_AMODE;
377 }
378
379 /* Create siginfo on the signal stack */
380 if (copy_siginfo_to_user32(&frame->info, &ksig->info))
381 return -EFAULT;
382
383 /* Store registers needed to create the signal frame */
384 store_sigregs();
385
386 /* Create ucontext on the signal stack. */
387 if (__put_user(uc_flags, &frame->uc.uc_flags) ||
388 __put_user(0, &frame->uc.uc_link) ||
389 __compat_save_altstack(&frame->uc.uc_stack, regs->gprs[15]) ||
390 save_sigregs32(regs, &frame->uc.uc_mcontext) ||
391 put_compat_sigset(&frame->uc.uc_sigmask, set, sizeof(compat_sigset_t)) ||
392 save_sigregs_ext32(regs, &frame->uc.uc_mcontext_ext))
393 return -EFAULT;
394
395 /* Set up registers for signal handler */
396 regs->gprs[14] = restorer;
397 regs->gprs[15] = (__force __u64) frame;
398 /* Force 31 bit amode and default user address space control. */
399 regs->psw.mask = PSW_MASK_BA |
400 (PSW_USER_BITS & PSW_MASK_ASC) |
401 (regs->psw.mask & ~PSW_MASK_ASC);
402 regs->psw.addr = (__u64 __force) ksig->ka.sa.sa_handler;
403
404 regs->gprs[2] = ksig->sig;
405 regs->gprs[3] = (__force __u64) &frame->info;
406 regs->gprs[4] = (__force __u64) &frame->uc;
407 regs->gprs[5] = current->thread.last_break;
408 return 0;
409}
410
411/*
412 * OK, we're invoking a handler
413 */
414
415void handle_signal32(struct ksignal *ksig, sigset_t *oldset,
416 struct pt_regs *regs)
417{
418 int ret;
419
420 /* Set up the stack frame */
421 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
422 ret = setup_rt_frame32(ksig, oldset, regs);
423 else
424 ret = setup_frame32(ksig, oldset, regs);
425
426 signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLE_STEP));
427}
428
1/*
2 * Copyright IBM Corp. 2000, 2006
3 * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
4 * Gerhard Tonn (ton@de.ibm.com)
5 *
6 * Copyright (C) 1991, 1992 Linus Torvalds
7 *
8 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
9 */
10
11#include <linux/compat.h>
12#include <linux/sched.h>
13#include <linux/mm.h>
14#include <linux/smp.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#include <linux/stddef.h>
22#include <linux/tty.h>
23#include <linux/personality.h>
24#include <linux/binfmts.h>
25#include <asm/ucontext.h>
26#include <asm/uaccess.h>
27#include <asm/lowcore.h>
28#include <asm/switch_to.h>
29#include "compat_linux.h"
30#include "compat_ptrace.h"
31#include "entry.h"
32
33typedef struct
34{
35 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
36 struct sigcontext32 sc;
37 _sigregs32 sregs;
38 int signo;
39 __u32 gprs_high[NUM_GPRS];
40 __u8 retcode[S390_SYSCALL_SIZE];
41} sigframe32;
42
43typedef struct
44{
45 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
46 __u8 retcode[S390_SYSCALL_SIZE];
47 compat_siginfo_t info;
48 struct ucontext32 uc;
49 __u32 gprs_high[NUM_GPRS];
50} rt_sigframe32;
51
52int copy_siginfo_to_user32(compat_siginfo_t __user *to, const siginfo_t *from)
53{
54 int err;
55
56 /* If you change siginfo_t structure, please be sure
57 this code is fixed accordingly.
58 It should never copy any pad contained in the structure
59 to avoid security leaks, but must copy the generic
60 3 ints plus the relevant union member.
61 This routine must convert siginfo from 64bit to 32bit as well
62 at the same time. */
63 err = __put_user(from->si_signo, &to->si_signo);
64 err |= __put_user(from->si_errno, &to->si_errno);
65 err |= __put_user((short)from->si_code, &to->si_code);
66 if (from->si_code < 0)
67 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
68 else {
69 switch (from->si_code >> 16) {
70 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
71 case __SI_MESGQ >> 16:
72 err |= __put_user(from->si_int, &to->si_int);
73 /* fallthrough */
74 case __SI_KILL >> 16:
75 err |= __put_user(from->si_pid, &to->si_pid);
76 err |= __put_user(from->si_uid, &to->si_uid);
77 break;
78 case __SI_CHLD >> 16:
79 err |= __put_user(from->si_pid, &to->si_pid);
80 err |= __put_user(from->si_uid, &to->si_uid);
81 err |= __put_user(from->si_utime, &to->si_utime);
82 err |= __put_user(from->si_stime, &to->si_stime);
83 err |= __put_user(from->si_status, &to->si_status);
84 break;
85 case __SI_FAULT >> 16:
86 err |= __put_user((unsigned long) from->si_addr,
87 &to->si_addr);
88 break;
89 case __SI_POLL >> 16:
90 err |= __put_user(from->si_band, &to->si_band);
91 err |= __put_user(from->si_fd, &to->si_fd);
92 break;
93 case __SI_TIMER >> 16:
94 err |= __put_user(from->si_tid, &to->si_tid);
95 err |= __put_user(from->si_overrun, &to->si_overrun);
96 err |= __put_user(from->si_int, &to->si_int);
97 break;
98 default:
99 break;
100 }
101 }
102 return err ? -EFAULT : 0;
103}
104
105int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
106{
107 int err;
108 u32 tmp;
109
110 err = __get_user(to->si_signo, &from->si_signo);
111 err |= __get_user(to->si_errno, &from->si_errno);
112 err |= __get_user(to->si_code, &from->si_code);
113
114 if (to->si_code < 0)
115 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
116 else {
117 switch (to->si_code >> 16) {
118 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
119 case __SI_MESGQ >> 16:
120 err |= __get_user(to->si_int, &from->si_int);
121 /* fallthrough */
122 case __SI_KILL >> 16:
123 err |= __get_user(to->si_pid, &from->si_pid);
124 err |= __get_user(to->si_uid, &from->si_uid);
125 break;
126 case __SI_CHLD >> 16:
127 err |= __get_user(to->si_pid, &from->si_pid);
128 err |= __get_user(to->si_uid, &from->si_uid);
129 err |= __get_user(to->si_utime, &from->si_utime);
130 err |= __get_user(to->si_stime, &from->si_stime);
131 err |= __get_user(to->si_status, &from->si_status);
132 break;
133 case __SI_FAULT >> 16:
134 err |= __get_user(tmp, &from->si_addr);
135 to->si_addr = (void __force __user *)
136 (u64) (tmp & PSW32_ADDR_INSN);
137 break;
138 case __SI_POLL >> 16:
139 err |= __get_user(to->si_band, &from->si_band);
140 err |= __get_user(to->si_fd, &from->si_fd);
141 break;
142 case __SI_TIMER >> 16:
143 err |= __get_user(to->si_tid, &from->si_tid);
144 err |= __get_user(to->si_overrun, &from->si_overrun);
145 err |= __get_user(to->si_int, &from->si_int);
146 break;
147 default:
148 break;
149 }
150 }
151 return err ? -EFAULT : 0;
152}
153
154static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs)
155{
156 _sigregs32 user_sregs;
157 int i;
158
159 user_sregs.regs.psw.mask = (__u32)(regs->psw.mask >> 32);
160 user_sregs.regs.psw.mask &= PSW32_MASK_USER | PSW32_MASK_RI;
161 user_sregs.regs.psw.mask |= PSW32_USER_BITS;
162 user_sregs.regs.psw.addr = (__u32) regs->psw.addr |
163 (__u32)(regs->psw.mask & PSW_MASK_BA);
164 for (i = 0; i < NUM_GPRS; i++)
165 user_sregs.regs.gprs[i] = (__u32) regs->gprs[i];
166 save_access_regs(current->thread.acrs);
167 memcpy(&user_sregs.regs.acrs, current->thread.acrs,
168 sizeof(user_sregs.regs.acrs));
169 save_fp_ctl(¤t->thread.fp_regs.fpc);
170 save_fp_regs(current->thread.fp_regs.fprs);
171 memcpy(&user_sregs.fpregs, ¤t->thread.fp_regs,
172 sizeof(user_sregs.fpregs));
173 if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs32)))
174 return -EFAULT;
175 return 0;
176}
177
178static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs)
179{
180 _sigregs32 user_sregs;
181 int i;
182
183 /* Alwys make any pending restarted system call return -EINTR */
184 current_thread_info()->restart_block.fn = do_no_restart_syscall;
185
186 if (__copy_from_user(&user_sregs, &sregs->regs, sizeof(user_sregs)))
187 return -EFAULT;
188
189 if (!is_ri_task(current) && (user_sregs.regs.psw.mask & PSW32_MASK_RI))
190 return -EINVAL;
191
192 /* Loading the floating-point-control word can fail. Do that first. */
193 if (restore_fp_ctl(&user_sregs.fpregs.fpc))
194 return -EINVAL;
195
196 /* Use regs->psw.mask instead of PSW_USER_BITS to preserve PER bit. */
197 regs->psw.mask = (regs->psw.mask & ~(PSW_MASK_USER | PSW_MASK_RI)) |
198 (__u64)(user_sregs.regs.psw.mask & PSW32_MASK_USER) << 32 |
199 (__u64)(user_sregs.regs.psw.mask & PSW32_MASK_RI) << 32 |
200 (__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_AMODE);
201 /* Check for invalid user address space control. */
202 if ((regs->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME)
203 regs->psw.mask = PSW_ASC_PRIMARY |
204 (regs->psw.mask & ~PSW_MASK_ASC);
205 regs->psw.addr = (__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_INSN);
206 for (i = 0; i < NUM_GPRS; i++)
207 regs->gprs[i] = (__u64) user_sregs.regs.gprs[i];
208 memcpy(¤t->thread.acrs, &user_sregs.regs.acrs,
209 sizeof(current->thread.acrs));
210 restore_access_regs(current->thread.acrs);
211
212 memcpy(¤t->thread.fp_regs, &user_sregs.fpregs,
213 sizeof(current->thread.fp_regs));
214
215 restore_fp_regs(current->thread.fp_regs.fprs);
216 clear_thread_flag(TIF_SYSCALL); /* No longer in a system call */
217 return 0;
218}
219
220static int save_sigregs_gprs_high(struct pt_regs *regs, __u32 __user *uregs)
221{
222 __u32 gprs_high[NUM_GPRS];
223 int i;
224
225 for (i = 0; i < NUM_GPRS; i++)
226 gprs_high[i] = regs->gprs[i] >> 32;
227 if (__copy_to_user(uregs, &gprs_high, sizeof(gprs_high)))
228 return -EFAULT;
229 return 0;
230}
231
232static int restore_sigregs_gprs_high(struct pt_regs *regs, __u32 __user *uregs)
233{
234 __u32 gprs_high[NUM_GPRS];
235 int i;
236
237 if (__copy_from_user(&gprs_high, uregs, sizeof(gprs_high)))
238 return -EFAULT;
239 for (i = 0; i < NUM_GPRS; i++)
240 *(__u32 *)®s->gprs[i] = gprs_high[i];
241 return 0;
242}
243
244COMPAT_SYSCALL_DEFINE0(sigreturn)
245{
246 struct pt_regs *regs = task_pt_regs(current);
247 sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
248 sigset_t set;
249
250 if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
251 goto badframe;
252 set_current_blocked(&set);
253 if (restore_sigregs32(regs, &frame->sregs))
254 goto badframe;
255 if (restore_sigregs_gprs_high(regs, frame->gprs_high))
256 goto badframe;
257 return regs->gprs[2];
258badframe:
259 force_sig(SIGSEGV, current);
260 return 0;
261}
262
263COMPAT_SYSCALL_DEFINE0(rt_sigreturn)
264{
265 struct pt_regs *regs = task_pt_regs(current);
266 rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
267 sigset_t set;
268
269 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
270 goto badframe;
271 set_current_blocked(&set);
272 if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
273 goto badframe;
274 if (restore_sigregs_gprs_high(regs, frame->gprs_high))
275 goto badframe;
276 if (compat_restore_altstack(&frame->uc.uc_stack))
277 goto badframe;
278 return regs->gprs[2];
279badframe:
280 force_sig(SIGSEGV, current);
281 return 0;
282}
283
284/*
285 * Set up a signal frame.
286 */
287
288
289/*
290 * Determine which stack to use..
291 */
292static inline void __user *
293get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
294{
295 unsigned long sp;
296
297 /* Default to using normal stack */
298 sp = (unsigned long) A(regs->gprs[15]);
299
300 /* Overflow on alternate signal stack gives SIGSEGV. */
301 if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
302 return (void __user *) -1UL;
303
304 /* This is the X/Open sanctioned signal stack switching. */
305 if (ka->sa.sa_flags & SA_ONSTACK) {
306 if (! sas_ss_flags(sp))
307 sp = current->sas_ss_sp + current->sas_ss_size;
308 }
309
310 return (void __user *)((sp - frame_size) & -8ul);
311}
312
313static inline int map_signal(int sig)
314{
315 if (current_thread_info()->exec_domain
316 && current_thread_info()->exec_domain->signal_invmap
317 && sig < 32)
318 return current_thread_info()->exec_domain->signal_invmap[sig];
319 else
320 return sig;
321}
322
323static int setup_frame32(int sig, struct k_sigaction *ka,
324 sigset_t *set, struct pt_regs * regs)
325{
326 sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32));
327
328 if (frame == (void __user *) -1UL)
329 goto give_sigsegv;
330
331 if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32))
332 goto give_sigsegv;
333
334 if (save_sigregs32(regs, &frame->sregs))
335 goto give_sigsegv;
336 if (save_sigregs_gprs_high(regs, frame->gprs_high))
337 goto give_sigsegv;
338 if (__put_user((unsigned long) &frame->sregs, &frame->sc.sregs))
339 goto give_sigsegv;
340
341 /* Set up to return from userspace. If provided, use a stub
342 already in userspace. */
343 if (ka->sa.sa_flags & SA_RESTORER) {
344 regs->gprs[14] = (__u64 __force) ka->sa.sa_restorer | PSW32_ADDR_AMODE;
345 } else {
346 regs->gprs[14] = (__u64 __force) frame->retcode | PSW32_ADDR_AMODE;
347 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
348 (u16 __force __user *)(frame->retcode)))
349 goto give_sigsegv;
350 }
351
352 /* Set up backchain. */
353 if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
354 goto give_sigsegv;
355
356 /* Set up registers for signal handler */
357 regs->gprs[15] = (__force __u64) frame;
358 /* Force 31 bit amode and default user address space control. */
359 regs->psw.mask = PSW_MASK_BA |
360 (PSW_USER_BITS & PSW_MASK_ASC) |
361 (regs->psw.mask & ~PSW_MASK_ASC);
362 regs->psw.addr = (__force __u64) ka->sa.sa_handler;
363
364 regs->gprs[2] = map_signal(sig);
365 regs->gprs[3] = (__force __u64) &frame->sc;
366
367 /* We forgot to include these in the sigcontext.
368 To avoid breaking binary compatibility, they are passed as args. */
369 if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL ||
370 sig == SIGTRAP || sig == SIGFPE) {
371 /* set extra registers only for synchronous signals */
372 regs->gprs[4] = regs->int_code & 127;
373 regs->gprs[5] = regs->int_parm_long;
374 regs->gprs[6] = task_thread_info(current)->last_break;
375 }
376
377 /* Place signal number on stack to allow backtrace from handler. */
378 if (__put_user(regs->gprs[2], (int __force __user *) &frame->signo))
379 goto give_sigsegv;
380 return 0;
381
382give_sigsegv:
383 force_sigsegv(sig, current);
384 return -EFAULT;
385}
386
387static int setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info,
388 sigset_t *set, struct pt_regs * regs)
389{
390 int err = 0;
391 rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32));
392
393 if (frame == (void __user *) -1UL)
394 goto give_sigsegv;
395
396 if (copy_siginfo_to_user32(&frame->info, info))
397 goto give_sigsegv;
398
399 /* Create the ucontext. */
400 err |= __put_user(UC_EXTENDED, &frame->uc.uc_flags);
401 err |= __put_user(0, &frame->uc.uc_link);
402 err |= __compat_save_altstack(&frame->uc.uc_stack, regs->gprs[15]);
403 err |= save_sigregs32(regs, &frame->uc.uc_mcontext);
404 err |= save_sigregs_gprs_high(regs, frame->gprs_high);
405 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
406 if (err)
407 goto give_sigsegv;
408
409 /* Set up to return from userspace. If provided, use a stub
410 already in userspace. */
411 if (ka->sa.sa_flags & SA_RESTORER) {
412 regs->gprs[14] = (__u64 __force) ka->sa.sa_restorer | PSW32_ADDR_AMODE;
413 } else {
414 regs->gprs[14] = (__u64 __force) frame->retcode | PSW32_ADDR_AMODE;
415 if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
416 (u16 __force __user *)(frame->retcode)))
417 goto give_sigsegv;
418 }
419
420 /* Set up backchain. */
421 if (__put_user(regs->gprs[15], (unsigned int __force __user *) frame))
422 goto give_sigsegv;
423
424 /* Set up registers for signal handler */
425 regs->gprs[15] = (__force __u64) frame;
426 /* Force 31 bit amode and default user address space control. */
427 regs->psw.mask = PSW_MASK_BA |
428 (PSW_USER_BITS & PSW_MASK_ASC) |
429 (regs->psw.mask & ~PSW_MASK_ASC);
430 regs->psw.addr = (__u64 __force) ka->sa.sa_handler;
431
432 regs->gprs[2] = map_signal(sig);
433 regs->gprs[3] = (__force __u64) &frame->info;
434 regs->gprs[4] = (__force __u64) &frame->uc;
435 regs->gprs[5] = task_thread_info(current)->last_break;
436 return 0;
437
438give_sigsegv:
439 force_sigsegv(sig, current);
440 return -EFAULT;
441}
442
443/*
444 * OK, we're invoking a handler
445 */
446
447void handle_signal32(unsigned long sig, struct k_sigaction *ka,
448 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
449{
450 int ret;
451
452 /* Set up the stack frame */
453 if (ka->sa.sa_flags & SA_SIGINFO)
454 ret = setup_rt_frame32(sig, ka, info, oldset, regs);
455 else
456 ret = setup_frame32(sig, ka, oldset, regs);
457 if (ret)
458 return;
459 signal_delivered(sig, info, ka, regs,
460 test_thread_flag(TIF_SINGLE_STEP));
461}
462